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

package/dist/server.cjs

@@ -59,8 +59,8 @@ function mountBearerAuth(app, opts) {
   ]);
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path71 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
-    if (exactUnauthPaths.has(path71) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path71)) {
+    const path74 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    if (exactUnauthPaths.has(path74) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path74)) {
       done();
       return;
     }
@@ -192,8 +192,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path50.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path50.default.resolve(here, "..", "proto");
+  const here = import_node_path53.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path53.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -261,13 +261,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path50, import_node_crypto2, grpc, protoLoader;
+var import_node_url, import_node_path53, 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_path50 = __toESM(require("path"), 1);
+    import_node_path53 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
@@ -413,8 +413,8 @@ function websocketChannelPathOf(attrs) {
     const v = attrs[key];
     if (typeof v === "string" && v.length > 0) {
       const q = v.indexOf("?");
-      const path71 = q === -1 ? v : v.slice(0, q);
-      if (path71.length > 0) return path71;
+      const path74 = q === -1 ? v : v.slice(0, q);
+      if (path74.length > 0) return path74;
     }
   }
   return void 0;
@@ -476,10 +476,10 @@ function parseOtlpRequest(body) {
   return out;
 }
 function loadProtoRoot() {
-  const here = import_node_path51.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path51.default.resolve(here, "..", "proto");
+  const here = import_node_path54.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path54.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path51.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path54.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -710,12 +710,12 @@ async function buildOtelReceiver(opts) {
   };
   return decorated;
 }
-var import_node_path51, import_node_url2, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
+var import_node_path54, import_node_url2, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path51 = __toESM(require("path"), 1);
+    import_node_path54 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     import_fastify = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
@@ -731,7 +731,7 @@ var init_otel = __esm({
 
 // src/server.ts
 init_cjs_shims();
-var import_node_path70 = __toESM(require("path"), 1);
+var import_node_path73 = __toESM(require("path"), 1);
 
 // src/graph.ts
 init_cjs_shims();
@@ -755,7 +755,7 @@ function getGraph(project = DEFAULT_PROJECT) {
 init_cjs_shims();
 var import_fastify2 = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types88 = require("@neat.is/types");
+var import_types91 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -2015,7 +2015,7 @@ var import_node_fs5 = require("fs");
 var import_node_path5 = __toESM(require("path"), 1);
 var import_yaml = require("yaml");
 var import_types3 = require("@neat.is/types");
-var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php", ".cs", ".java"]);
+var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php", ".cs", ".java", ".kt", ".rs", ".cpp", ".cc", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".h++"]);
 var CONFIG_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
 var JSON_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["app.json", "app.config.json", "eas.json"]);
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
@@ -2284,7 +2284,8 @@ function buildServiceHostIndex(services) {
   }
   return { knownHosts, hostToNodeId };
 }
-async function walkSourceFiles(dir) {
+async function walkSourceFiles(dir, excludeDirs = []) {
+  const excluded = new Set(excludeDirs.map((d) => import_node_path7.default.resolve(d)));
   const out = [];
   async function walk9(current) {
     const entries = await import_node_fs7.promises.readdir(current, { withFileTypes: true }).catch(() => []);
@@ -2292,6 +2293,7 @@ async function walkSourceFiles(dir) {
       const full = import_node_path7.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
+        if (excluded.has(import_node_path7.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk9(full);
       } else if (entry.isFile() && SERVICE_FILE_EXTENSIONS.has(import_node_path7.default.extname(entry.name)) && // Skip NEAT's own generated `otel-init.*` bootstrap — extracting it
@@ -2304,8 +2306,8 @@ async function walkSourceFiles(dir) {
   await walk9(dir);
   return out;
 }
-async function loadSourceFiles(dir) {
-  const paths = await walkSourceFiles(dir);
+async function loadSourceFiles(dir, excludeDirs = []) {
+  const paths = await walkSourceFiles(dir, excludeDirs);
   const out = [];
   for (const p of paths) {
     try {
@@ -2342,6 +2344,19 @@ function languageForPath(relPath) {
       return "csharp";
     case ".java":
       return "java";
+    case ".kt":
+      return "kotlin";
+    case ".rs":
+      return "rust";
+    case ".cpp":
+    case ".cc":
+    case ".cxx":
+    case ".c++":
+    case ".hpp":
+    case ".hh":
+    case ".hxx":
+    case ".h++":
+      return "cpp";
     case ".ts":
     case ".tsx":
       return "typescript";
@@ -2675,6 +2690,7 @@ async function resolveGoImport(specifier, modulePath, serviceDir) {
 function emitImportEdge(graph, serviceName, importerFileId, importerRelPath, importeeRelPath, line, snippet2) {
   const importeeFileId = (0, import_types5.fileId)(serviceName, importeeRelPath);
   if (!graph.hasNode(importeeFileId)) return 0;
+  if (importerFileId === importeeFileId) return 0;
   const edgeId = (0, import_types5.extractedEdgeId)(importerFileId, importeeFileId, import_types5.EdgeType.IMPORTS);
   if (graph.hasEdge(edgeId)) return 0;
   const edge = {
@@ -2696,7 +2712,7 @@ async function addImports(graph, services) {
   let edgesAdded = 0;
   for (const service of services) {
     const tsPaths = await loadTsPathConfig(service.dir);
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
       const relFile = toPosix(import_node_path8.default.relative(service.dir, file.path));
@@ -2878,8 +2894,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path71) {
-  return path71.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path74) {
+  return path74.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -3551,9 +3567,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path71 = rubyLiteral(k);
-    if (path71 === null) continue;
-    return { path: path71, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path74 = rubyLiteral(k);
+    if (path74 === null) continue;
+    return { path: path74, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -4238,7 +4254,7 @@ async function addRoutes(graph, services) {
     const hasLaravel = deps["laravel/framework"] !== void 0;
     if (!hasExpress && !hasFastify && !hasHono && !hasNext && !hasNestjs && !hasFastapi && !hasFlask && !hasDjango && !hasGin && !hasEcho && !hasFiber && !hasChi && !isGoService && !hasRails && !hasLaravel)
       continue;
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     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;
@@ -5596,29 +5612,29 @@ function promoteFrontierNodes(graph, opts = {}) {
     toPromote.push({ frontierId: id, serviceId: target });
   });
   let promoted = 0;
-  for (const { frontierId: frontierId2, serviceId: serviceId12 } of toPromote) {
+  for (const { frontierId: frontierId2, serviceId: serviceId15 } of toPromote) {
     if (opts.policies && opts.policies.length > 0 && opts.policyCtx) {
       const gate = canPromoteFrontier(graph, frontierId2, opts.policies, opts.policyCtx);
       if (!gate.allowed) {
         continue;
       }
     }
-    rewireFrontierEdges(graph, frontierId2, serviceId12);
+    rewireFrontierEdges(graph, frontierId2, serviceId15);
     graph.dropNode(frontierId2);
     promoted++;
   }
   return promoted;
 }
-function rewireFrontierEdges(graph, frontierId2, serviceId12) {
+function rewireFrontierEdges(graph, frontierId2, serviceId15) {
   const inbound = [...graph.inboundEdges(frontierId2)];
   const outbound = [...graph.outboundEdges(frontierId2)];
   for (const edgeId of inbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, edge.source, serviceId12, edgeId);
+    rebuildEdge(graph, edge, edge.source, serviceId15, edgeId);
   }
   for (const edgeId of outbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, serviceId12, edge.target, edgeId);
+    rebuildEdge(graph, edge, serviceId15, edge.target, edgeId);
   }
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
@@ -5937,19 +5953,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, path71, edges) {
-    if (path71.length > best.path.length) {
-      best = { path: [...path71], edges: [...edges] };
+  function step(node, path74, edges) {
+    if (path74.length > best.path.length) {
+      best = { path: [...path74], edges: [...edges] };
     }
-    if (path71.length - 1 >= maxDepth) return;
+    if (path74.length - 1 >= maxDepth) return;
     const incoming = bestEdgeBySource(graph, graph.inboundEdges(node));
     for (const [srcId, edge] of incoming) {
       if (visited.has(srcId)) continue;
       visited.add(srcId);
-      path71.push(srcId);
+      path74.push(srcId);
       edges.push(edge);
-      step(srcId, path71, edges);
-      path71.pop();
+      step(srcId, path74, edges);
+      path74.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -5964,7 +5980,7 @@ function databaseRootCauseShape(graph, origin, walk9) {
   for (const id of walk9.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId12, svc } = owner;
+    const { id: serviceId15, svc } = owner;
     const deps = svc.dependencies ?? {};
     for (const pair of candidatePairs) {
       const declared = deps[pair.driver];
@@ -5977,7 +5993,7 @@ function databaseRootCauseShape(graph, origin, walk9) {
       );
       if (!result.compatible) {
         return {
-          rootCauseNode: serviceId12,
+          rootCauseNode: serviceId15,
           rootCauseReason: result.reason ?? "incompatible driver",
           ...result.minDriverVersion ? {
             fixRecommendation: `Upgrade ${svc.name} ${pair.driver} driver to >= ${result.minDriverVersion}`
@@ -5992,7 +6008,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
   for (const id of walk9.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId12, svc } = owner;
+    const { id: serviceId15, svc } = owner;
     const deps = svc.dependencies ?? {};
     const serviceNodeEngine = svc.nodeEngine;
     for (const constraint of nodeEngineConstraints()) {
@@ -6001,7 +6017,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
       const result = checkNodeEngineConstraint(constraint, declared, serviceNodeEngine);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId12,
+          rootCauseNode: serviceId15,
           rootCauseReason: result.reason,
           ...result.requiredNodeVersion ? {
             fixRecommendation: `Bump ${svc.name}'s engines.node to >= ${result.requiredNodeVersion}`
@@ -6016,7 +6032,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
       const result = checkPackageConflict(conflict, declared, requiredDeclared);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId12,
+          rootCauseNode: serviceId15,
           rootCauseReason: result.reason,
           fixRecommendation: `Upgrade ${svc.name}'s ${conflict.requires.name} to >= ${conflict.requires.minVersion}`
         };
@@ -6117,9 +6133,9 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
 function isFailingCallEdge(e) {
   return e.type === import_types8.EdgeType.CALLS && (e.signal?.errorCount ?? 0) > 0;
 }
-function callSourcesForService(graph, serviceId12) {
-  const ids = [serviceId12];
-  for (const edgeId of graph.outboundEdges(serviceId12)) {
+function callSourcesForService(graph, serviceId15) {
+  const ids = [serviceId15];
+  for (const edgeId of graph.outboundEdges(serviceId15)) {
     const e = graph.getEdgeAttributes(edgeId);
     if (e.type !== import_types8.EdgeType.CONTAINS) continue;
     const tgt = graph.getNodeAttributes(e.target);
@@ -6143,9 +6159,9 @@ function failingCallDominates(e, id, curEdge, curId) {
   }
   return id < curId;
 }
-function dominantFailingCall(graph, serviceId12, visited) {
+function dominantFailingCall(graph, serviceId15, visited) {
   let best = null;
-  for (const src of callSourcesForService(graph, serviceId12)) {
+  for (const src of callSourcesForService(graph, serviceId15)) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (!isFailingCallEdge(e)) continue;
@@ -6160,26 +6176,26 @@ function dominantFailingCall(graph, serviceId12, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path71 = [originServiceId];
+  const path74 = [originServiceId];
   const edges = [];
   const visited = /* @__PURE__ */ new Set([originServiceId]);
   let current = originServiceId;
   for (let depth = 0; depth < maxDepth; depth++) {
     const hop = dominantFailingCall(graph, current, visited);
     if (!hop) break;
-    path71.push(hop.nextService);
+    path74.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path71, edges, culprit: current };
+  return { path: path74, edges, culprit: current };
 }
 function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   const chain = followFailingCallChain(graph, originId, ROOT_CAUSE_MAX_DEPTH);
   if (!chain) return null;
   const culprit = chain.culprit;
-  const path71 = [...chain.path];
+  const path74 = [...chain.path];
   const edgeProvenances = chain.edges.map((e) => e.provenance);
   const baseConfidence = confidenceFromMix(chain.edges);
   const confidence = Math.max(0, Math.min(1, baseConfidence * INCIDENT_ROOT_CAUSE_CONFIDENCE));
@@ -6187,14 +6203,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path71.push(loc.fileNode);
+      path74.push(loc.fileNode);
       edgeProvenances.push(import_types8.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return import_types8.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path71,
+      traversalPath: path74,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -6206,7 +6222,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   return import_types8.RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
-    traversalPath: path71,
+    traversalPath: path74,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -6642,10 +6658,10 @@ function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
   let traversalPath = legacy.traversalPath;
   let edgeProvenances = legacy.edgeProvenances;
   if (top.node !== seedNode) {
-    const path71 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path71) {
-      traversalPath = path71.nodes;
-      edgeProvenances = path71.edges.map((e) => e.provenance);
+    const path74 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path74) {
+      traversalPath = path74.nodes;
+      edgeProvenances = path74.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? import_types8.Provenance.OBSERVED];
@@ -7057,11 +7073,11 @@ init_cjs_shims();
 
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs17 = require("fs");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
+var import_node_path22 = __toESM(require("path"), 1);
 var import_ignore = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
-var import_types16 = require("@neat.is/types");
+var import_types19 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
@@ -7386,11 +7402,158 @@ async function discoverJavaService(scanPath, dir) {
   return { pkg, dir, node };
 }
 
-// src/extract/dockerfile-service.ts
+// src/extract/kotlin.ts
 init_cjs_shims();
 var import_node_fs15 = require("fs");
 var import_node_path17 = __toESM(require("path"), 1);
 var import_types15 = require("@neat.is/types");
+var KOTLIN_SOURCE_EXT = ".kt";
+var JAVA_SOURCE_EXT = ".java";
+var SOURCE_PROBE_MAX_DEPTH = 8;
+async function dominantJvmSourceLanguage(dir) {
+  let kt = 0;
+  let java = 0;
+  async function recurse(current, depth) {
+    if (depth > SOURCE_PROBE_MAX_DEPTH) return;
+    const entries = await import_node_fs15.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        await recurse(import_node_path17.default.join(current, entry.name), depth + 1);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const ext = import_node_path17.default.extname(entry.name).toLowerCase();
+      if (ext === KOTLIN_SOURCE_EXT) kt++;
+      else if (ext === JAVA_SOURCE_EXT) java++;
+    }
+  }
+  await recurse(dir, 0);
+  if (kt > 0 && kt >= java) return "kotlin";
+  if (java > 0) return "java";
+  return void 0;
+}
+async function readJvmManifest(dir) {
+  const pomPath = import_node_path17.default.join(dir, JAVA_MANIFESTS[0]);
+  const gradlePath = import_node_path17.default.join(dir, JAVA_MANIFESTS[1]);
+  const gradleKtsPath = import_node_path17.default.join(dir, JAVA_MANIFESTS[2]);
+  if (await exists2(pomPath)) {
+    return parsePomXml(await import_node_fs15.promises.readFile(pomPath, "utf8").catch(() => ""));
+  }
+  if (await exists2(gradlePath)) {
+    return parseGradle(await import_node_fs15.promises.readFile(gradlePath, "utf8").catch(() => ""));
+  }
+  if (await exists2(gradleKtsPath)) {
+    return parseGradle(await import_node_fs15.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
+  }
+  return null;
+}
+async function discoverKotlinService(scanPath, dir) {
+  if (!await hasJavaManifest(dir)) return null;
+  if (await dominantJvmSourceLanguage(dir) !== "kotlin") return null;
+  const manifest = await readJvmManifest(dir);
+  if (!manifest) return null;
+  const name = manifest.name?.trim() || import_node_path17.default.basename(dir);
+  const dependencies = manifest.dependencies;
+  const pkg = { name, dependencies };
+  const node = {
+    id: (0, import_types15.serviceId)(name),
+    type: import_types15.NodeType.ServiceNode,
+    name,
+    language: "kotlin",
+    dependencies,
+    repoPath: import_node_path17.default.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+
+// src/extract/rust.ts
+init_cjs_shims();
+var import_node_fs16 = require("fs");
+var import_node_path18 = __toESM(require("path"), 1);
+var import_smol_toml2 = require("smol-toml");
+var import_types16 = require("@neat.is/types");
+var CARGO_MANIFEST = "Cargo.toml";
+async function hasRustManifest(dir) {
+  return exists2(import_node_path18.default.join(dir, CARGO_MANIFEST));
+}
+function parseCargoToml(source) {
+  const dependencies = {};
+  let name;
+  let parsed;
+  try {
+    parsed = (0, import_smol_toml2.parse)(source);
+  } catch {
+    return { dependencies };
+  }
+  if (typeof parsed.package?.name === "string") name = parsed.package.name;
+  for (const [crate, spec] of Object.entries(parsed.dependencies ?? {})) {
+    if (typeof spec === "string") {
+      dependencies[crate] = spec;
+    } else if (spec && typeof spec === "object") {
+      const version = spec.version;
+      dependencies[crate] = typeof version === "string" ? version : "";
+    } else {
+      dependencies[crate] = "";
+    }
+  }
+  return { name, dependencies };
+}
+async function discoverRustService(scanPath, dir) {
+  const cargoPath = import_node_path18.default.join(dir, CARGO_MANIFEST);
+  if (!await exists2(cargoPath)) return null;
+  const manifest = parseCargoToml(await import_node_fs16.promises.readFile(cargoPath, "utf8").catch(() => ""));
+  const name = manifest.name?.trim() || import_node_path18.default.basename(dir);
+  const dependencies = manifest.dependencies;
+  const pkg = { name, dependencies };
+  const node = {
+    id: (0, import_types16.serviceId)(name),
+    type: import_types16.NodeType.ServiceNode,
+    name,
+    language: "rust",
+    dependencies,
+    repoPath: import_node_path18.default.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+
+// src/extract/cpp.ts
+init_cjs_shims();
+var import_node_fs17 = require("fs");
+var import_node_path19 = __toESM(require("path"), 1);
+var import_types17 = require("@neat.is/types");
+var CMAKE_MANIFEST = "CMakeLists.txt";
+async function hasCppManifest(dir) {
+  return exists2(import_node_path19.default.join(dir, CMAKE_MANIFEST));
+}
+function parseCMakeProjectName(source) {
+  const withoutComments = source.replace(/#.*$/gm, "");
+  const m = withoutComments.match(/\bproject\s*\(\s*"?([A-Za-z0-9_.+-]+)"?/i);
+  return m?.[1];
+}
+async function discoverCppService(scanPath, dir) {
+  const cmakePath = import_node_path19.default.join(dir, CMAKE_MANIFEST);
+  if (!await exists2(cmakePath)) return null;
+  const source = await import_node_fs17.promises.readFile(cmakePath, "utf8").catch(() => "");
+  const name = parseCMakeProjectName(source)?.trim() || import_node_path19.default.basename(dir);
+  const dependencies = {};
+  const pkg = { name, dependencies };
+  const node = {
+    id: (0, import_types17.serviceId)(name),
+    type: import_types17.NodeType.ServiceNode,
+    name,
+    language: "cpp",
+    dependencies,
+    repoPath: import_node_path19.default.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+
+// src/extract/dockerfile-service.ts
+init_cjs_shims();
+var import_node_fs18 = require("fs");
+var import_node_path20 = __toESM(require("path"), 1);
+var import_types18 = require("@neat.is/types");
 function languageForSourceExt(ext) {
   switch (ext) {
     case ".py":
@@ -7405,6 +7568,19 @@ function languageForSourceExt(ext) {
       return "csharp";
     case ".java":
       return "java";
+    case ".kt":
+      return "kotlin";
+    case ".rs":
+      return "rust";
+    case ".cpp":
+    case ".cc":
+    case ".cxx":
+    case ".c++":
+    case ".hpp":
+    case ".hh":
+    case ".hxx":
+    case ".h++":
+      return "cpp";
     case ".ts":
     case ".tsx":
       return "typescript";
@@ -7416,14 +7592,14 @@ function languageForSourceExt(ext) {
       return null;
   }
 }
-var LANGUAGE_PRECEDENCE = ["typescript", "javascript", "python", "go", "ruby", "php", "csharp", "java"];
+var LANGUAGE_PRECEDENCE = ["typescript", "javascript", "python", "go", "ruby", "php", "csharp", "java", "kotlin", "rust", "cpp"];
 async function inferServiceLanguage(dir) {
-  const entries = await import_node_fs15.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs18.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   const counts = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (isNeatAuthoredSourceFile(entry.name)) continue;
-    const ext = import_node_path17.default.extname(entry.name).toLowerCase();
+    const ext = import_node_path20.default.extname(entry.name).toLowerCase();
     if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
     const lang = languageForSourceExt(ext);
     if (!lang) continue;
@@ -7442,46 +7618,50 @@ async function inferServiceLanguage(dir) {
   return best;
 }
 async function hasLanguageManifest(dir) {
-  return await exists2(import_node_path17.default.join(dir, "package.json")) || await exists2(import_node_path17.default.join(dir, "pyproject.toml")) || await exists2(import_node_path17.default.join(dir, "requirements.txt")) || await exists2(import_node_path17.default.join(dir, "setup.py")) || await exists2(import_node_path17.default.join(dir, "go.mod")) || await exists2(import_node_path17.default.join(dir, "Gemfile")) || await exists2(import_node_path17.default.join(dir, "composer.json")) || // C#'s marker is a glob (`*.csproj` / `*.sln`), so it reads the directory
+  return await exists2(import_node_path20.default.join(dir, "package.json")) || await exists2(import_node_path20.default.join(dir, "pyproject.toml")) || await exists2(import_node_path20.default.join(dir, "requirements.txt")) || await exists2(import_node_path20.default.join(dir, "setup.py")) || await exists2(import_node_path20.default.join(dir, "go.mod")) || await exists2(import_node_path20.default.join(dir, "Gemfile")) || await exists2(import_node_path20.default.join(dir, "composer.json")) || // C#'s marker is a glob (`*.csproj` / `*.sln`), so it reads the directory
   // rather than probing a fixed filename (ADR-196).
-  await hasCsharpProject(dir) || // Java keys on a Maven / Gradle build manifest (ADR-197).
-  await hasJavaManifest(dir);
+  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
+  // down for both.
+  await hasJavaManifest(dir) || // Rust's marker is a fixed `Cargo.toml` (ADR-201).
+  await hasRustManifest(dir) || // C++'s marker is a fixed `CMakeLists.txt` (ADR-202).
+  await hasCppManifest(dir);
 }
 async function hasDockerfileDeclaredService(dir) {
-  if (!await exists2(import_node_path17.default.join(dir, "Dockerfile"))) return false;
+  if (!await exists2(import_node_path20.default.join(dir, "Dockerfile"))) return false;
   return await inferServiceLanguage(dir) !== null;
 }
 async function discoverDockerfileService(scanPath, dir) {
-  if (!await exists2(import_node_path17.default.join(dir, "Dockerfile"))) return null;
+  if (!await exists2(import_node_path20.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_path17.default.basename(dir);
+  const name = import_node_path20.default.basename(dir);
   const pkg = { name, dependencies: {} };
   const node = {
-    id: (0, import_types15.serviceId)(name),
-    type: import_types15.NodeType.ServiceNode,
+    id: (0, import_types18.serviceId)(name),
+    type: import_types18.NodeType.ServiceNode,
     name,
     language,
     dependencies: {},
-    repoPath: import_node_path17.default.relative(scanPath, dir)
+    repoPath: import_node_path20.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/owners.ts
 init_cjs_shims();
-var import_node_fs16 = require("fs");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs19 = require("fs");
+var import_node_path21 = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path18.default.join(scanPath, "CODEOWNERS"),
-    import_node_path18.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path21.default.join(scanPath, "CODEOWNERS"),
+    import_node_path21.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists2(file)) {
-      const raw = await import_node_fs16.promises.readFile(file, "utf8");
+      const raw = await import_node_fs19.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -7499,7 +7679,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path18.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path21.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -7515,7 +7695,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path18.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path21.default.join(serviceDir, "package.json");
   if (!await exists2(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -7552,36 +7732,36 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists2(import_node_path19.default.join(dir, "pyproject.toml")) || await exists2(import_node_path19.default.join(dir, "requirements.txt")) || await exists2(import_node_path19.default.join(dir, "setup.py"));
+  return await exists2(import_node_path22.default.join(dir, "pyproject.toml")) || await exists2(import_node_path22.default.join(dir, "requirements.txt")) || await exists2(import_node_path22.default.join(dir, "setup.py"));
 }
 async function hasGoManifest(dir) {
-  return exists2(import_node_path19.default.join(dir, "go.mod"));
+  return exists2(import_node_path22.default.join(dir, "go.mod"));
 }
 async function hasRubyManifest(dir) {
-  return exists2(import_node_path19.default.join(dir, "Gemfile"));
+  return exists2(import_node_path22.default.join(dir, "Gemfile"));
 }
 async function hasPhpManifest(dir) {
-  return exists2(import_node_path19.default.join(dir, "composer.json"));
+  return exists2(import_node_path22.default.join(dir, "composer.json"));
 }
 async function hasCsharpManifest(dir) {
   return hasCsharpProject(dir);
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path19.default.join(scanPath, ".gitignore");
+  const gitignorePath = import_node_path22.default.join(scanPath, ".gitignore");
   if (!await exists2(gitignorePath)) return null;
-  const raw = await import_node_fs17.promises.readFile(gitignorePath, "utf8");
+  const raw = await import_node_fs20.promises.readFile(gitignorePath, "utf8");
   return (0, import_ignore.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_fs17.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs20.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path19.default.join(current, entry.name);
+      const child = import_node_path22.default.join(current, entry.name);
       if (options.ig) {
-        const rel = import_node_path19.default.relative(scanPath, child).split(import_node_path19.default.sep).join("/");
+        const rel = import_node_path22.default.relative(scanPath, child).split(import_node_path22.default.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -7597,8 +7777,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = import_node_path19.default.join(scanPath, pattern);
-      if (await exists2(import_node_path19.default.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = import_node_path22.default.join(scanPath, pattern);
+      if (await exists2(import_node_path22.default.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -7607,13 +7787,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = import_node_path19.default.join(scanPath, ...staticSegments);
+    const start = import_node_path22.default.join(scanPath, ...staticSegments);
     if (!await exists2(start)) continue;
     const hasDoubleStar = pattern.includes("**");
     const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
     await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
-      const rel = import_node_path19.default.relative(scanPath, dir).split(import_node_path19.default.sep).join("/");
-      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists2(import_node_path19.default.join(dir, "package.json"))) {
+      const rel = import_node_path22.default.relative(scanPath, dir).split(import_node_path22.default.sep).join("/");
+      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists2(import_node_path22.default.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -7636,31 +7816,31 @@ function detectJsFramework(pkg) {
 async function detectJsServiceLanguage(dir, pkg) {
   const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   if (deps["typescript"] !== void 0) return "typescript";
-  const entries = await import_node_fs17.promises.readdir(dir).catch(() => []);
+  const entries = await import_node_fs20.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_path19.default.join(dir, "package.json");
+  const pkgPath = import_node_path22.default.join(dir, "package.json");
   if (!await exists2(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", import_node_path19.default.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", import_node_path22.default.relative(scanPath, pkgPath), err);
     return null;
   }
   if (!pkg.name) return null;
   const framework = detectJsFramework(pkg);
   const language = await detectJsServiceLanguage(dir, pkg);
   const node = {
-    id: (0, import_types16.serviceId)(pkg.name),
-    type: import_types16.NodeType.ServiceNode,
+    id: (0, import_types19.serviceId)(pkg.name),
+    type: import_types19.NodeType.ServiceNode,
     name: pkg.name,
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path19.default.relative(scanPath, dir),
+    repoPath: import_node_path22.default.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -7671,18 +7851,18 @@ async function discoverPyService(scanPath, dir) {
   if (!py) return null;
   const pkg = pythonToPackage(py);
   const node = {
-    id: (0, import_types16.serviceId)(py.name),
-    type: import_types16.NodeType.ServiceNode,
+    id: (0, import_types19.serviceId)(py.name),
+    type: import_types19.NodeType.ServiceNode,
     name: py.name,
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: import_node_path19.default.relative(scanPath, dir)
+    repoPath: import_node_path22.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path19.default.join(scanPath, "package.json");
+  const rootPkgPath = import_node_path22.default.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists2(rootPkgPath)) {
     try {
@@ -7690,7 +7870,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        import_node_path19.default.relative(scanPath, rootPkgPath),
+        import_node_path22.default.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -7702,7 +7882,7 @@ async function discoverServices(scanPath) {
   } else {
     if (rootPkg && rootPkg.name) {
       candidateDirs.push(scanPath);
-    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath) || await hasRubyManifest(scanPath) || await hasPhpManifest(scanPath) || await hasCsharpManifest(scanPath) || await hasJavaManifest(scanPath)) {
+    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath) || await hasRubyManifest(scanPath) || await hasPhpManifest(scanPath) || await hasCsharpManifest(scanPath) || await hasJavaManifest(scanPath) || await hasRustManifest(scanPath) || await hasCppManifest(scanPath)) {
       candidateDirs.push(scanPath);
     }
     const ig = await loadGitignore(scanPath);
@@ -7711,9 +7891,9 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists2(import_node_path19.default.join(dir, "package.json"))) {
+        if (await exists2(import_node_path22.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)) {
+        } 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);
         } else if (await hasDockerfileDeclaredService(dir)) {
           candidateDirs.push(dir);
@@ -7726,14 +7906,21 @@ async function discoverServices(scanPath) {
   const seenDirs = /* @__PURE__ */ new Set();
   const out = [];
   for (const dir of candidateDirs) {
-    const service = await discoverNodeService(scanPath, dir) ?? await discoverPyService(scanPath, dir) ?? await discoverGoService(scanPath, dir) ?? await discoverRubyService(scanPath, dir) ?? await discoverPhpService(scanPath, dir) ?? await discoverCsharpService(scanPath, dir) ?? await discoverJavaService(scanPath, dir) ?? await discoverDockerfileService(scanPath, dir);
+    const service = await discoverNodeService(scanPath, dir) ?? await discoverPyService(scanPath, dir) ?? await discoverGoService(scanPath, dir) ?? await discoverRubyService(scanPath, dir) ?? await discoverPhpService(scanPath, dir) ?? await discoverCsharpService(scanPath, dir) ?? // Kotlin runs ahead of Java: both mark a service with the same Maven/Gradle
+    // manifest, so Kotlin claims a JVM-manifest dir whose source is `.kt` (ADR-199)
+    // and a `.java`-dominant one falls through to the Java reader unchanged.
+    await discoverKotlinService(scanPath, dir) ?? await discoverJavaService(scanPath, dir) ?? // Rust keys on a `Cargo.toml`, a manifest no other language shares (ADR-201),
+    // so its order among the distinct-manifest discoverers doesn't matter.
+    await discoverRustService(scanPath, dir) ?? // C++ keys on a `CMakeLists.txt`, likewise a manifest no other language shares
+    // (ADR-202), so it too sits anywhere among the distinct-manifest discoverers.
+    await discoverCppService(scanPath, dir) ?? await discoverDockerfileService(scanPath, dir);
     if (!service) continue;
     if (seenDirs.has(service.dir)) continue;
     seenDirs.add(service.dir);
     const existingDir = seen.get(service.node.name);
     if (existingDir !== void 0) {
-      const a = import_node_path19.default.relative(scanPath, existingDir) || ".";
-      const b = import_node_path19.default.relative(scanPath, dir) || ".";
+      const a = import_node_path22.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path22.default.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -7747,6 +7934,17 @@ async function discoverServices(scanPath) {
     const owner = await computeServiceOwner(codeowners, service.node.repoPath, service.dir);
     if (owner !== void 0) service.node.owner = owner;
   }
+  const resolvedDirs = out.map((s) => import_node_path22.default.resolve(s.dir));
+  for (let i = 0; i < out.length; i++) {
+    const self = resolvedDirs[i];
+    const nested = [];
+    for (let j = 0; j < out.length; j++) {
+      if (i === j) continue;
+      const other = resolvedDirs[j];
+      if (other.startsWith(self + import_node_path22.default.sep)) nested.push(other);
+    }
+    out[i].excludeDirs = nested;
+  }
   return out;
 }
 function addServiceNodes(graph, services) {
@@ -7770,20 +7968,20 @@ function addServiceNodes(graph, services) {
 
 // src/extract/aliases.ts
 init_cjs_shims();
-var import_node_path20 = __toESM(require("path"), 1);
-var import_node_fs18 = require("fs");
+var import_node_path23 = __toESM(require("path"), 1);
+var import_node_fs21 = require("fs");
 var import_yaml2 = require("yaml");
-var import_types17 = require("@neat.is/types");
+var import_types20 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
   "Service",
   "Deployment",
   "StatefulSet",
   "DaemonSet"
 ]);
-function addAliases(graph, serviceId12, candidates) {
-  if (!graph.hasNode(serviceId12)) return;
-  const node = graph.getNodeAttributes(serviceId12);
-  if (node.type !== import_types17.NodeType.ServiceNode) return;
+function addAliases(graph, serviceId15, candidates) {
+  if (!graph.hasNode(serviceId15)) return;
+  const node = graph.getNodeAttributes(serviceId15);
+  if (node.type !== import_types20.NodeType.ServiceNode) return;
   const set = new Set(node.aliases ?? []);
   for (const c of candidates) {
     if (!c) continue;
@@ -7792,20 +7990,20 @@ function addAliases(graph, serviceId12, candidates) {
   }
   if (set.size === 0) return;
   const updated = { ...node, aliases: [...set].sort() };
-  graph.replaceNodeAttributes(serviceId12, updated);
+  graph.replaceNodeAttributes(serviceId15, updated);
 }
 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_path20.default.basename(s.dir), s.node.id);
+    map.set(import_node_path23.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_path20.default.join(scanPath, name);
+    const abs = import_node_path23.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -7818,19 +8016,19 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      import_node_path20.default.relative(scanPath, composePath),
+      import_node_path23.default.relative(scanPath, composePath),
       err
     );
     return;
   }
   if (!compose?.services) return;
   for (const [composeName, svc] of Object.entries(compose.services)) {
-    const serviceId12 = serviceIndex.get(composeName);
-    if (!serviceId12) continue;
+    const serviceId15 = serviceIndex.get(composeName);
+    if (!serviceId15) continue;
     const aliases = /* @__PURE__ */ new Set([composeName]);
     if (svc.container_name) aliases.add(svc.container_name);
     if (svc.hostname) aliases.add(svc.hostname);
-    addAliases(graph, serviceId12, aliases);
+    addAliases(graph, serviceId15, aliases);
   }
 }
 var LABEL_KEYS = /* @__PURE__ */ new Set([
@@ -7861,11 +8059,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = import_node_path20.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path23.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs18.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs21.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -7877,15 +8075,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_fs18.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs21.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path20.default.join(start, entry.name);
+      const child = import_node_path23.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles(child, depth + 1, max));
-    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path20.default.extname(entry.name))) {
-      out.push(import_node_path20.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path23.default.extname(entry.name))) {
+      out.push(import_node_path23.default.join(start, entry.name));
     }
   }
   return out;
@@ -7912,7 +8110,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_fs18.promises.readFile(file, "utf8");
+    const content = await import_node_fs21.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -7937,14 +8135,14 @@ async function addServiceAliases(graph, scanPath, services) {
 
 // src/extract/files.ts
 init_cjs_shims();
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path24 = __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);
+    const filePaths = await walkSourceFiles(service.dir, service.excludeDirs);
     for (const filePath of filePaths) {
-      const relPath = toPosix(import_node_path21.default.relative(service.dir, filePath));
+      const relPath = toPosix(import_node_path24.default.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -7960,7 +8158,7 @@ async function addFiles(graph, services) {
 
 // src/extract/symbols.ts
 init_cjs_shims();
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path25 = __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);
@@ -7970,7 +8168,10 @@ var import_tree_sitter_ruby2 = __toESM(require("tree-sitter-ruby"), 1);
 var import_tree_sitter_php2 = __toESM(require("tree-sitter-php"), 1);
 var import_tree_sitter_c_sharp = __toESM(require("tree-sitter-c-sharp"), 1);
 var import_tree_sitter_java = __toESM(require("tree-sitter-java"), 1);
-var import_types18 = require("@neat.is/types");
+var import_tree_sitter_kotlin = __toESM(require("tree-sitter-kotlin"), 1);
+var import_tree_sitter_rust = __toESM(require("tree-sitter-rust"), 1);
+var import_tree_sitter_cpp = __toESM(require("tree-sitter-cpp"), 1);
+var import_types21 = require("@neat.is/types");
 var PARSE_CHUNK3 = 16384;
 var GRAMMAR_BY_EXT = {
   ".ts": import_tree_sitter_typescript.default.typescript,
@@ -7987,7 +8188,25 @@ var SYMBOL_GRAMMAR_BY_EXT = {
   ".rb": import_tree_sitter_ruby2.default,
   ".php": import_tree_sitter_php2.default.php_only,
   ".cs": import_tree_sitter_c_sharp.default,
-  ".java": import_tree_sitter_java.default
+  ".java": import_tree_sitter_java.default,
+  ".kt": import_tree_sitter_kotlin.default,
+  ".rs": import_tree_sitter_rust.default,
+  // C++ (ADR-202) — only the UNAMBIGUOUS extensions. `.cpp` / `.cc` / `.cxx` /
+  // `.c++` are implementation files; `.hpp` / `.hh` / `.hxx` / `.h++` are C++-only
+  // headers. `.h` and `.c` are deliberately absent: they are shared with C (a
+  // language NEAT does not add), and this map is global — the symbol grain
+  // dispatches on extension, not on the owning service's language — so claiming
+  // `.h` would parse every pure-C header in any repo with the C++ grammar and
+  // mislabel it. The otel-demo `currency` target's executable code lives in a
+  // `.cpp`, so nothing is lost.
+  ".cpp": import_tree_sitter_cpp.default,
+  ".cc": import_tree_sitter_cpp.default,
+  ".cxx": import_tree_sitter_cpp.default,
+  ".c++": import_tree_sitter_cpp.default,
+  ".hpp": import_tree_sitter_cpp.default,
+  ".hh": import_tree_sitter_cpp.default,
+  ".hxx": import_tree_sitter_cpp.default,
+  ".h++": import_tree_sitter_cpp.default
 };
 function parseSource3(parser, source) {
   return parser.parse(
@@ -8400,6 +8619,237 @@ function collectJavaSymbolDefs(root) {
   walkChildren(root, void 0);
   return out;
 }
+function collectKotlinSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+  const firstChildOfType = (node, types) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && types.includes(child.type)) return child;
+    }
+    return void 0;
+  };
+  const nameOf = (node, ...types) => firstChildOfType(node, types)?.text;
+  const bodyOf = (node) => firstChildOfType(node, ["class_body", "enum_class_body"]);
+  let pkg;
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+    if (child?.type === "package_header") {
+      pkg = child.namedChild(0)?.text;
+      break;
+    }
+  }
+  const walkChildren = (container, classCtx) => {
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (child) visit(child, classCtx);
+    }
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "class_declaration":
+      case "object_declaration": {
+        const name = nameOf(node, "type_identifier");
+        const full = name ? join(classCtx ?? pkg, name) : classCtx;
+        if (name) push("class", full, node);
+        const body = bodyOf(node);
+        if (body) walkChildren(body, full);
+        return;
+      }
+      case "companion_object": {
+        const name = nameOf(node, "type_identifier");
+        const full = name ? join(classCtx ?? pkg, name) : classCtx ?? pkg;
+        const body = bodyOf(node);
+        if (body) walkChildren(body, full);
+        return;
+      }
+      case "function_declaration": {
+        const name = nameOf(node, "simple_identifier");
+        if (name) push(classCtx ? "method" : "function", join(classCtx ?? pkg, name), node);
+        return;
+      }
+      case "secondary_constructor": {
+        if (classCtx) {
+          const typeName = classCtx.slice(classCtx.lastIndexOf(".") + 1);
+          push("constructor", join(classCtx, typeName), node);
+        }
+        return;
+      }
+    }
+    walkChildren(node, classCtx);
+  };
+  walkChildren(root, void 0);
+  return out;
+}
+function collectRustSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const join = (prefix, name) => prefix ? `${prefix}::${name}` : name;
+  const walkTypeBody = (body, typeCtx) => {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const child = body.namedChild(i);
+      if (!child) continue;
+      if (child.type === "function_item" || child.type === "function_signature_item") {
+        const name = child.childForFieldName("name")?.text;
+        if (name) push("method", join(typeCtx, name), child);
+      }
+    }
+  };
+  const walkChildren = (container, modCtx) => {
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (child) visit(child, modCtx);
+    }
+  };
+  const visit = (node, modCtx) => {
+    switch (node.type) {
+      case "mod_item": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(modCtx, name) : modCtx;
+        const body = node.childForFieldName("body");
+        if (body) walkChildren(body, full);
+        return;
+      }
+      case "struct_item":
+      case "enum_item": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("class", join(modCtx, name), node);
+        return;
+      }
+      case "trait_item": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(modCtx, name) : modCtx;
+        if (name) push("class", full, node);
+        const body = node.childForFieldName("body");
+        if (body && full) walkTypeBody(body, full);
+        return;
+      }
+      case "impl_item": {
+        const typeName = node.childForFieldName("type")?.text;
+        const full = typeName ? join(modCtx, typeName) : modCtx;
+        const body = node.childForFieldName("body");
+        if (body && full) walkTypeBody(body, full);
+        return;
+      }
+      case "function_item": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("function", join(modCtx, name), node);
+        return;
+      }
+    }
+    walkChildren(node, modCtx);
+  };
+  walkChildren(root, void 0);
+  return out;
+}
+function collectCppSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const join = (prefix, name) => prefix ? `${prefix}::${name}` : name;
+  const DECLARATOR_WRAPPERS = /* @__PURE__ */ new Set([
+    "function_declarator",
+    "pointer_declarator",
+    "reference_declarator",
+    "parenthesized_declarator"
+  ]);
+  const functionNameNode = (node) => {
+    let decl = node.childForFieldName("declarator");
+    for (let guard = 0; decl && guard < 8; guard++) {
+      if (decl.type === "function_declarator") {
+        return decl.childForFieldName("declarator") ?? void 0;
+      }
+      let next;
+      for (let i = 0; i < decl.namedChildCount; i++) {
+        const child = decl.namedChild(i);
+        if (child && DECLARATOR_WRAPPERS.has(child.type)) {
+          next = child;
+          break;
+        }
+      }
+      decl = next;
+    }
+    return void 0;
+  };
+  const classify = (nameText, prefix, enclosingClass) => {
+    const qualname = join(prefix, nameText);
+    let className;
+    let memberName;
+    const idx = nameText.lastIndexOf("::");
+    if (idx >= 0) {
+      memberName = nameText.slice(idx + 2);
+      const before = nameText.slice(0, idx);
+      const j = before.lastIndexOf("::");
+      className = j >= 0 ? before.slice(j + 2) : before;
+    } else {
+      memberName = nameText;
+      className = enclosingClass;
+    }
+    let kind;
+    if (className && memberName === className) kind = "constructor";
+    else if (className) kind = "method";
+    else kind = "function";
+    return { kind, qualname };
+  };
+  const walkChildren = (container, prefix, enclosingClass) => {
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (child) visit(child, prefix, enclosingClass);
+    }
+  };
+  const visit = (node, prefix, enclosingClass) => {
+    switch (node.type) {
+      case "namespace_definition": {
+        const name = node.childForFieldName("name")?.text;
+        const newPrefix = name ? join(prefix, name) : prefix;
+        const body = node.childForFieldName("body");
+        if (body) walkChildren(body, newPrefix, void 0);
+        return;
+      }
+      case "class_specifier":
+      case "struct_specifier": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(prefix, name) : prefix;
+        if (name) push("class", full, node);
+        const body = node.childForFieldName("body");
+        if (body && name) walkChildren(body, full, name);
+        return;
+      }
+      case "function_definition": {
+        const nameNode = functionNameNode(node);
+        if (nameNode) {
+          const { kind, qualname } = classify(nameNode.text, prefix, enclosingClass);
+          push(kind, qualname, node);
+        }
+        return;
+      }
+    }
+    walkChildren(node, prefix, enclosingClass);
+  };
+  walkChildren(root, void 0, void 0);
+  return out;
+}
 function collectSymbolDefsForExt(ext, root) {
   switch (ext) {
     case ".py":
@@ -8414,6 +8864,19 @@ function collectSymbolDefsForExt(ext, root) {
       return collectCsharpSymbolDefs(root);
     case ".java":
       return collectJavaSymbolDefs(root);
+    case ".kt":
+      return collectKotlinSymbolDefs(root);
+    case ".rs":
+      return collectRustSymbolDefs(root);
+    case ".cpp":
+    case ".cc":
+    case ".cxx":
+    case ".c++":
+    case ".hpp":
+    case ".hh":
+    case ".hxx":
+    case ".h++":
+      return collectCppSymbolDefs(root);
     default:
       return collectSymbolDefs(root);
   }
@@ -8445,12 +8908,12 @@ async function addSymbols(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
-      const ext = import_node_path22.default.extname(file.path);
+      const ext = import_node_path25.default.extname(file.path);
       const parser = parserForExt5(ext);
       if (!parser) continue;
-      const relPath = toPosix(import_node_path22.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path25.default.relative(service.dir, file.path));
       let defs;
       try {
         const tree = parseSource3(parser, file.content);
@@ -8469,11 +8932,11 @@ async function addSymbols(graph, services) {
       nodesAdded += fn;
       edgesAdded += fe;
       for (const { def, disambiguator } of disambiguate(defs)) {
-        const sid = (0, import_types18.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
+        const sid = (0, import_types21.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
         if (!graph.hasNode(sid)) {
           const node = {
             id: sid,
-            type: import_types18.NodeType.SymbolNode,
+            type: import_types21.NodeType.SymbolNode,
             kind: def.kind,
             qualname: def.qualname,
             span: { startLine: def.startLine, endLine: def.endLine },
@@ -8484,15 +8947,15 @@ async function addSymbols(graph, services) {
           graph.addNode(sid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types18.extractedEdgeId)(fileNodeId, sid, import_types18.EdgeType.CONTAINS);
+        const containsId = (0, import_types21.extractedEdgeId)(fileNodeId, sid, import_types21.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: fileNodeId,
             target: sid,
-            type: import_types18.EdgeType.CONTAINS,
-            provenance: import_types18.Provenance.EXTRACTED,
-            confidence: (0, import_types18.confidenceForExtracted)("structural"),
+            type: import_types21.EdgeType.CONTAINS,
+            provenance: import_types21.Provenance.EXTRACTED,
+            confidence: (0, import_types21.confidenceForExtracted)("structural"),
             evidence: {
               file: relPath,
               line: def.startLine,
@@ -8510,9 +8973,9 @@ async function addSymbols(graph, services) {
 
 // src/extract/symbol-edges.ts
 init_cjs_shims();
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
-var import_types19 = require("@neat.is/types");
+var import_types22 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
   for (let i = 0; i < classHeritage.namedChildCount; i++) {
     const child = classHeritage.namedChild(i);
@@ -8615,12 +9078,12 @@ async function addSymbolEdges(graph, services) {
   for (const service of services) {
     const serviceName = service.pkg.name;
     const tsPaths = await loadTsPathConfig(service.dir);
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
-      const parser = parserForExt5(import_node_path23.default.extname(file.path));
+      const parser = parserForExt5(import_node_path26.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path23.default.relative(service.dir, file.path));
-      const fileDir = import_node_path23.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;
@@ -8630,7 +9093,7 @@ async function addSymbolEdges(graph, services) {
       }
       const disambiguated = disambiguate(collectSymbolDefs(root));
       const locals = disambiguated.map(({ def, disambiguator }) => ({
-        sid: (0, import_types19.symbolId)(serviceName, relPath, def.qualname, disambiguator),
+        sid: (0, import_types22.symbolId)(serviceName, relPath, def.qualname, disambiguator),
         qualname: def.qualname,
         kind: def.kind,
         startLine: def.startLine,
@@ -8659,10 +9122,10 @@ async function addSymbolEdges(graph, services) {
         if (local) return local.kind === wantKind ? local.sid : null;
         const imp = resolvedImports.get(name);
         if (imp) {
-          const candidate = (0, import_types19.symbolId)(serviceName, imp.targetRelPath, imp.importedName);
+          const candidate = (0, import_types22.symbolId)(serviceName, imp.targetRelPath, imp.importedName);
           if (graph.hasNode(candidate)) {
             const node = graph.getNodeAttributes(candidate);
-            if (node.type === import_types19.NodeType.SymbolNode && node.kind === wantKind) return candidate;
+            if (node.type === import_types22.NodeType.SymbolNode && node.kind === wantKind) return candidate;
           }
         }
         return null;
@@ -8689,7 +9152,7 @@ async function addSymbolEdges(graph, services) {
                   sourceSid: self.sid,
                   targetName: ext.name,
                   wantKind: "class",
-                  edgeType: import_types19.EdgeType.INHERITS,
+                  edgeType: import_types22.EdgeType.INHERITS,
                   line: ext.line
                 });
               }
@@ -8698,7 +9161,7 @@ async function addSymbolEdges(graph, services) {
                   sourceSid: self.sid,
                   targetName: impl.name,
                   wantKind: "class",
-                  edgeType: import_types19.EdgeType.IMPLEMENTS,
+                  edgeType: import_types22.EdgeType.IMPLEMENTS,
                   line: impl.line
                 });
               }
@@ -8714,7 +9177,7 @@ async function addSymbolEdges(graph, services) {
                 sourceSid: caller.sid,
                 targetName: fn.text,
                 wantKind: "function",
-                edgeType: import_types19.EdgeType.CALLS,
+                edgeType: import_types22.EdgeType.CALLS,
                 line
               });
             }
@@ -8730,15 +9193,15 @@ async function addSymbolEdges(graph, services) {
         const targetSid = resolveTarget(req.targetName, req.wantKind);
         if (!targetSid) continue;
         if (targetSid === req.sourceSid) continue;
-        const edgeId = (0, import_types19.extractedEdgeId)(req.sourceSid, targetSid, req.edgeType);
+        const edgeId = (0, import_types22.extractedEdgeId)(req.sourceSid, targetSid, req.edgeType);
         if (graph.hasEdge(edgeId)) continue;
         const edge = {
           id: edgeId,
           source: req.sourceSid,
           target: targetSid,
           type: req.edgeType,
-          provenance: import_types19.Provenance.EXTRACTED,
-          confidence: (0, import_types19.confidenceForExtracted)("structural"),
+          provenance: import_types22.Provenance.EXTRACTED,
+          confidence: (0, import_types22.confidenceForExtracted)("structural"),
           evidence: {
             file: relPath,
             line: req.line,
@@ -8755,9 +9218,9 @@ async function addSymbolEdges(graph, services) {
 
 // src/extract/actions.ts
 init_cjs_shims();
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 var import_tree_sitter5 = __toESM(require("tree-sitter"), 1);
-var import_types20 = require("@neat.is/types");
+var import_types23 = require("@neat.is/types");
 function stringLiteralText2(node) {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
@@ -8899,12 +9362,12 @@ async function addServerActions(graph, services) {
     };
     if (deps["next"] === void 0) continue;
     const tsPaths = await loadTsPathConfig(service.dir);
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(import_node_path24.default.extname(file.path));
+      const parser = parserForExt5(import_node_path27.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path24.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path27.default.relative(service.dir, file.path));
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8927,11 +9390,11 @@ async function addServerActions(graph, services) {
       nodesAdded += fn;
       edgesAdded += fe;
       for (const action of actions) {
-        const aid = (0, import_types20.serverActionId)(service.pkg.name, relPath, action.exportName);
+        const aid = (0, import_types23.serverActionId)(service.pkg.name, relPath, action.exportName);
         if (!graph.hasNode(aid)) {
           const node = {
             id: aid,
-            type: import_types20.NodeType.ServerActionNode,
+            type: import_types23.NodeType.ServerActionNode,
             name: action.exportName,
             service: service.pkg.name,
             module: relPath,
@@ -8943,15 +9406,15 @@ async function addServerActions(graph, services) {
           graph.addNode(aid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types20.extractedEdgeId)(fileNodeId, aid, import_types20.EdgeType.CONTAINS);
+        const containsId = (0, import_types23.extractedEdgeId)(fileNodeId, aid, import_types23.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: fileNodeId,
             target: aid,
-            type: import_types20.EdgeType.CONTAINS,
-            provenance: import_types20.Provenance.EXTRACTED,
-            confidence: (0, import_types20.confidenceForExtracted)("structural"),
+            type: import_types23.EdgeType.CONTAINS,
+            provenance: import_types23.Provenance.EXTRACTED,
+            confidence: (0, import_types23.confidenceForExtracted)("structural"),
             evidence: {
               file: relPath,
               line: action.line,
@@ -8965,10 +9428,10 @@ async function addServerActions(graph, services) {
     }
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(import_node_path24.default.extname(file.path));
+      const parser = parserForExt5(import_node_path27.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_path27.default.relative(service.dir, file.path));
+      const fileDir = import_node_path27.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8981,7 +9444,7 @@ async function addServerActions(graph, services) {
       for (const [local, binding] of bindings) {
         const target = await resolveJsImport(binding.specifier, fileDir, service.dir, tsPaths);
         if (!target) continue;
-        const aid = (0, import_types20.serverActionId)(service.pkg.name, target, binding.importedName);
+        const aid = (0, import_types23.serverActionId)(service.pkg.name, target, binding.importedName);
         if (graph.hasNode(aid)) actionBindings.set(local, aid);
       }
       if (actionBindings.size === 0) continue;
@@ -8996,15 +9459,15 @@ async function addServerActions(graph, services) {
           nodesAdded += ensured.nodesAdded;
           edgesAdded += ensured.edgesAdded;
         }
-        const callsId = (0, import_types20.extractedEdgeId)(clientFileId, aid, import_types20.EdgeType.CALLS);
+        const callsId = (0, import_types23.extractedEdgeId)(clientFileId, aid, import_types23.EdgeType.CALLS);
         if (graph.hasEdge(callsId)) continue;
         const edge = {
           id: callsId,
           source: clientFileId,
           target: aid,
-          type: import_types20.EdgeType.CALLS,
-          provenance: import_types20.Provenance.EXTRACTED,
-          confidence: (0, import_types20.confidenceForExtracted)("structural"),
+          type: import_types23.EdgeType.CALLS,
+          provenance: import_types23.Provenance.EXTRACTED,
+          confidence: (0, import_types23.confidenceForExtracted)("structural"),
           evidence: {
             file: relPath,
             line,
@@ -9021,14 +9484,14 @@ async function addServerActions(graph, services) {
 
 // src/extract/databases/index.ts
 init_cjs_shims();
-var import_node_path32 = __toESM(require("path"), 1);
-var import_types21 = require("@neat.is/types");
+var import_node_path35 = __toESM(require("path"), 1);
+var import_types24 = require("@neat.is/types");
 
 // src/extract/databases/db-config-yaml.ts
 init_cjs_shims();
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 async function parse(serviceDir) {
-  const yamlPath = import_node_path25.default.join(serviceDir, "db-config.yaml");
+  const yamlPath = import_node_path28.default.join(serviceDir, "db-config.yaml");
   if (!await exists2(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -9046,13 +9509,13 @@ var dbConfigYamlParser = { name: "db-config.yaml", parse };
 
 // src/extract/databases/dotenv.ts
 init_cjs_shims();
-var import_node_fs20 = require("fs");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_fs23 = require("fs");
+var import_node_path30 = __toESM(require("path"), 1);
 
 // src/extract/databases/shared.ts
 init_cjs_shims();
-var import_node_fs19 = require("fs");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_fs22 = require("fs");
+var import_node_path29 = __toESM(require("path"), 1);
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -9091,18 +9554,18 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await import_node_fs19.promises.readFile(filePath, "utf8");
+    return await import_node_fs22.promises.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function resolveEnvVar(serviceDir, name) {
-  const entries = await import_node_fs19.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs22.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_path26.default.join(serviceDir, fileName));
+    const content = await readIfExists(import_node_path29.default.join(serviceDir, fileName));
     if (!content) continue;
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -9121,7 +9584,7 @@ async function resolveEnvVar(serviceDir, name) {
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = import_node_path26.default.join(serviceDir, rel);
+    const abs = import_node_path29.default.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -9179,15 +9642,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await import_node_fs20.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs23.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
   const configs = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const match = isConfigFile(entry.name);
     if (!match.match || match.fileType !== "env") continue;
-    const filePath = import_node_path27.default.join(serviceDir, entry.name);
-    const content = await import_node_fs20.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path30.default.join(serviceDir, entry.name);
+    const content = await import_node_fs23.promises.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -9206,9 +9669,9 @@ var dotenvParser = { name: ".env", parse: parse2 };
 
 // src/extract/databases/prisma.ts
 init_cjs_shims();
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 async function parse3(serviceDir) {
-  const schemaPath = import_node_path28.default.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = import_node_path31.default.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -9366,10 +9829,10 @@ var knexParser = { name: "knex", parse: parse5 };
 
 // src/extract/databases/ormconfig.ts
 init_cjs_shims();
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = import_node_path29.default.join(serviceDir, candidate);
+    const abs = import_node_path32.default.join(serviceDir, candidate);
     if (!await exists2(abs)) continue;
     const raw = candidate.endsWith(".json") ? await readJson(abs) : await readYaml(abs);
     const entries = Array.isArray(raw) ? raw : [raw];
@@ -9429,9 +9892,9 @@ var typeormParser = { name: "typeorm", parse: parse7 };
 
 // src/extract/databases/sequelize.ts
 init_cjs_shims();
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 async function parse8(serviceDir) {
-  const configPath = import_node_path30.default.join(serviceDir, "config", "config.json");
+  const configPath = import_node_path33.default.join(serviceDir, "config", "config.json");
   if (!await exists2(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -9458,7 +9921,7 @@ var sequelizeParser = { name: "sequelize", parse: parse8 };
 
 // src/extract/databases/docker-compose.ts
 init_cjs_shims();
-var import_node_path31 = __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);
@@ -9485,7 +9948,7 @@ function databaseFromEnv(svc) {
 }
 async function parse9(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path31.default.join(serviceDir, name);
+    const abs = import_node_path34.default.join(serviceDir, name);
     if (!await exists2(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -9526,8 +9989,8 @@ function compatibleDriversFor(engine) {
 }
 function toDatabaseNode(config) {
   return {
-    id: (0, import_types21.databaseId)(config.host),
-    type: import_types21.NodeType.DatabaseNode,
+    id: (0, import_types24.databaseId)(config.host),
+    type: import_types24.NodeType.DatabaseNode,
     name: config.database || config.host,
     engine: config.engine,
     engineVersion: config.engineVersion,
@@ -9657,7 +10120,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix(import_node_path32.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,
@@ -9666,14 +10129,14 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix(import_node_path32.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_types21.EdgeType.CONNECTS_TO),
+        id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types24.EdgeType.CONNECTS_TO),
         source: fileNodeId,
         target: dbNode.id,
-        type: import_types21.EdgeType.CONNECTS_TO,
-        provenance: import_types21.Provenance.EXTRACTED,
-        confidence: (0, import_types21.confidenceForExtracted)("structural"),
+        type: import_types24.EdgeType.CONNECTS_TO,
+        provenance: import_types24.Provenance.EXTRACTED,
+        confidence: (0, import_types24.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       if (!graph.hasEdge(edge.id)) {
@@ -9684,26 +10147,26 @@ 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_path32.default.relative(scanPath, primary.sourceFile);
-      const cfgId = (0, import_types21.configId)(relPath);
+      const relPath = import_node_path35.default.relative(scanPath, primary.sourceFile);
+      const cfgId = (0, import_types24.configId)(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
-          type: import_types21.NodeType.ConfigNode,
-          name: import_node_path32.default.basename(primary.sourceFile),
+          type: import_types24.NodeType.ConfigNode,
+          name: import_node_path35.default.basename(primary.sourceFile),
           path: relPath,
-          fileType: isConfigFile(import_node_path32.default.basename(primary.sourceFile)).fileType || "config"
+          fileType: isConfigFile(import_node_path35.default.basename(primary.sourceFile)).fileType || "config"
         };
         graph.addNode(cfgId, cfgNode);
         nodesAdded++;
       }
       const cfgEdge = {
-        id: (0, import_types3.extractedEdgeId)(service.node.id, cfgId, import_types21.EdgeType.CONFIGURED_BY),
+        id: (0, import_types3.extractedEdgeId)(service.node.id, cfgId, import_types24.EdgeType.CONFIGURED_BY),
         source: service.node.id,
         target: cfgId,
-        type: import_types21.EdgeType.CONFIGURED_BY,
-        provenance: import_types21.Provenance.EXTRACTED,
-        confidence: (0, import_types21.confidenceForExtracted)("structural"),
+        type: import_types24.EdgeType.CONFIGURED_BY,
+        provenance: import_types24.Provenance.EXTRACTED,
+        confidence: (0, import_types24.confidenceForExtracted)("structural"),
         evidence: { file: toPosix(relPath) }
       };
       if (!graph.hasEdge(cfgEdge.id)) {
@@ -9733,17 +10196,19 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 
 // src/extract/configs.ts
 init_cjs_shims();
-var import_node_fs21 = require("fs");
-var import_node_path33 = __toESM(require("path"), 1);
-var import_types22 = require("@neat.is/types");
-async function walkConfigFiles(dir) {
+var import_node_fs24 = require("fs");
+var import_node_path36 = __toESM(require("path"), 1);
+var import_types25 = require("@neat.is/types");
+async function walkConfigFiles(dir, excludeDirs = []) {
+  const excluded = new Set(excludeDirs.map((d) => import_node_path36.default.resolve(d)));
   const out = [];
   async function walk9(current) {
-    const entries = await import_node_fs21.promises.readdir(current, { withFileTypes: true });
+    const entries = await import_node_fs24.promises.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = import_node_path33.default.join(current, entry.name);
+      const full = import_node_path36.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
+        if (excluded.has(import_node_path36.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk9(full);
       } else if (entry.isFile() && isConfigFile(entry.name).match) {
@@ -9758,21 +10223,21 @@ async function addConfigNodes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const configFiles = await walkConfigFiles(service.dir);
+    const configFiles = await walkConfigFiles(service.dir, service.excludeDirs);
     for (const file of configFiles) {
-      const relPath = import_node_path33.default.relative(scanPath, file);
+      const relPath = import_node_path36.default.relative(scanPath, file);
       const node = {
-        id: (0, import_types22.configId)(relPath),
-        type: import_types22.NodeType.ConfigNode,
-        name: import_node_path33.default.basename(file),
+        id: (0, import_types25.configId)(relPath),
+        type: import_types25.NodeType.ConfigNode,
+        name: import_node_path36.default.basename(file),
         path: relPath,
-        fileType: isConfigFile(import_node_path33.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_path33.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,
@@ -9782,13 +10247,13 @@ async function addConfigNodes(graph, services, scanPath) {
       nodesAdded += fn;
       edgesAdded += fe;
       const edge = {
-        id: (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types22.EdgeType.CONFIGURED_BY),
+        id: (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types25.EdgeType.CONFIGURED_BY),
         source: fileNodeId,
         target: node.id,
-        type: import_types22.EdgeType.CONFIGURED_BY,
-        provenance: import_types22.Provenance.EXTRACTED,
-        confidence: (0, import_types22.confidenceForExtracted)("structural"),
-        evidence: { file: relPath.split(import_node_path33.default.sep).join("/") }
+        type: import_types25.EdgeType.CONFIGURED_BY,
+        provenance: import_types25.Provenance.EXTRACTED,
+        confidence: (0, import_types25.confidenceForExtracted)("structural"),
+        evidence: { file: relPath.split(import_node_path36.default.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -9801,9 +10266,9 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/proto.ts
 init_cjs_shims();
-var import_node_fs22 = require("fs");
-var import_node_path34 = __toESM(require("path"), 1);
-var import_types23 = require("@neat.is/types");
+var import_node_fs25 = require("fs");
+var import_node_path37 = __toESM(require("path"), 1);
+var import_types26 = require("@neat.is/types");
 var PROTO_EXTENSION = ".proto";
 function packageOf(content) {
   const m = content.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_.]*)\s*;/m);
@@ -9839,17 +10304,19 @@ function grpcMethodsFromProto(content, fqPackage) {
   }
   return out;
 }
-async function walkProtoFiles(dir) {
+async function walkProtoFiles(dir, excludeDirs = []) {
+  const excluded = new Set(excludeDirs.map((d) => import_node_path37.default.resolve(d)));
   const out = [];
   async function walk9(current) {
-    const entries = await import_node_fs22.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs25.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = import_node_path34.default.join(current, entry.name);
+      const full = import_node_path37.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
+        if (excluded.has(import_node_path37.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk9(full);
-      } else if (entry.isFile() && import_node_path34.default.extname(entry.name) === PROTO_EXTENSION) {
+      } else if (entry.isFile() && import_node_path37.default.extname(entry.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -9861,13 +10328,13 @@ async function addGrpcMethods(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const protoPaths = await walkProtoFiles(service.dir);
+    const protoPaths = await walkProtoFiles(service.dir, service.excludeDirs);
     for (const protoPath of protoPaths) {
       if (isTestPath(protoPath)) continue;
-      const relFile = toPosix(import_node_path34.default.relative(service.dir, protoPath));
+      const relFile = toPosix(import_node_path37.default.relative(service.dir, protoPath));
       let content;
       try {
-        content = await import_node_fs22.promises.readFile(protoPath, "utf8");
+        content = await import_node_fs25.promises.readFile(protoPath, "utf8");
       } catch (err) {
         recordExtractionError("proto extraction", protoPath, err);
         continue;
@@ -9881,11 +10348,11 @@ async function addGrpcMethods(graph, services) {
       }
       if (methods.length === 0) continue;
       for (const method of methods) {
-        const mid = (0, import_types23.grpcMethodId)(method.rpcService, method.rpcMethod);
+        const mid = (0, import_types26.grpcMethodId)(method.rpcService, method.rpcMethod);
         if (!graph.hasNode(mid)) {
           const node = {
             id: mid,
-            type: import_types23.NodeType.GrpcMethodNode,
+            type: import_types26.NodeType.GrpcMethodNode,
             name: `${method.rpcService}/${method.rpcMethod}`,
             rpcService: method.rpcService,
             rpcMethod: method.rpcMethod,
@@ -9896,15 +10363,15 @@ async function addGrpcMethods(graph, services) {
           graph.addNode(mid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types23.extractedEdgeId)(service.node.id, mid, import_types23.EdgeType.CONTAINS);
+        const containsId = (0, import_types26.extractedEdgeId)(service.node.id, mid, import_types26.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: service.node.id,
             target: mid,
-            type: import_types23.EdgeType.CONTAINS,
-            provenance: import_types23.Provenance.EXTRACTED,
-            confidence: (0, import_types23.confidenceForExtracted)("structural"),
+            type: import_types26.EdgeType.CONTAINS,
+            provenance: import_types26.Provenance.EXTRACTED,
+            confidence: (0, import_types26.confidenceForExtracted)("structural"),
             evidence: {
               file: relFile,
               line: method.line,
@@ -9922,16 +10389,16 @@ async function addGrpcMethods(graph, services) {
 
 // src/extract/calls/index.ts
 init_cjs_shims();
-var import_types41 = require("@neat.is/types");
+var import_types44 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
-var import_node_path35 = __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);
 var import_tree_sitter_python4 = __toESM(require("tree-sitter-python"), 1);
-var import_types24 = require("@neat.is/types");
+var import_types27 = require("@neat.is/types");
 var STRING_LITERAL_NODE_TYPES = /* @__PURE__ */ new Set(["string_fragment", "string_content"]);
 var JSX_EXTERNAL_LINK_TAGS = /* @__PURE__ */ new Set(["a", "Link", "NavLink", "ExternalLink", "Anchor"]);
 function isInsideJsxExternalLink(node) {
@@ -10005,11 +10472,11 @@ async function addHttpCallEdges(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt(import_node_path35.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);
@@ -10018,14 +10485,14 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path35.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;
         const dedupKey = `${relFile}|${targetId}`;
         if (seen.has(dedupKey)) continue;
         seen.add(dedupKey);
-        const confidence = (0, import_types24.confidenceForExtracted)("url-literal-service-target");
+        const confidence = (0, import_types27.confidenceForExtracted)("url-literal-service-target");
         const ev = {
           file: relFile,
           line: site.line,
@@ -10039,25 +10506,25 @@ async function addHttpCallEdges(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        if (!(0, import_types24.passesExtractedFloor)(confidence)) {
+        if (!(0, import_types27.passesExtractedFloor)(confidence)) {
           noteExtractedDropped({
             source: fileNodeId,
             target: targetId,
-            type: import_types24.EdgeType.CALLS,
+            type: import_types27.EdgeType.CALLS,
             confidence,
             confidenceKind: "url-literal-service-target",
             evidence: ev
           });
           continue;
         }
-        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, targetId, import_types24.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, targetId, import_types27.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: targetId,
-            type: import_types24.EdgeType.CALLS,
-            provenance: import_types24.Provenance.EXTRACTED,
+            type: import_types27.EdgeType.CALLS,
+            provenance: import_types27.Provenance.EXTRACTED,
             confidence,
             evidence: ev
           };
@@ -10072,10 +10539,10 @@ async function addHttpCallEdges(graph, services) {
 
 // src/extract/calls/route-match.ts
 init_cjs_shims();
-var import_node_path36 = __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_types25 = require("@neat.is/types");
+var import_types28 = require("@neat.is/types");
 var PARSE_CHUNK5 = 16384;
 function parseSource5(parser, source) {
   return parser.parse(
@@ -10240,9 +10707,9 @@ function buildRouteIndex(graph) {
   const index = /* @__PURE__ */ new Map();
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types25.NodeType.RouteNode) return;
+    if (node.type !== import_types28.NodeType.RouteNode) return;
     const route = attrs;
-    const owner = (0, import_types25.serviceId)(route.service);
+    const owner = (0, import_types28.serviceId)(route.service);
     const entry = {
       method: route.method.toUpperCase(),
       normalizedPath: normalizePathTemplate(route.pathTemplate),
@@ -10267,11 +10734,11 @@ async function addRouteCallEdges(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      if (!JS_CLIENT_EXTENSIONS.has(import_node_path36.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);
@@ -10280,7 +10747,7 @@ async function addRouteCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path36.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path39.default.relative(service.dir, file.path));
       for (const site of sites) {
         const serverServiceId = hostToNodeId.get(site.host);
         if (!serverServiceId || serverServiceId === service.node.id) continue;
@@ -10300,7 +10767,7 @@ async function addRouteCallEdges(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        const confidence = (0, import_types25.confidenceForExtracted)("verified-call-site");
+        const confidence = (0, import_types28.confidenceForExtracted)("verified-call-site");
         const ev = {
           file: relFile,
           line: site.line,
@@ -10308,25 +10775,25 @@ async function addRouteCallEdges(graph, services) {
           method: site.method ?? match.method,
           pathTemplate: site.pathTemplate
         };
-        if (!(0, import_types25.passesExtractedFloor)(confidence)) {
+        if (!(0, import_types28.passesExtractedFloor)(confidence)) {
           noteExtractedDropped({
             source: fileNodeId,
             target: match.routeNodeId,
-            type: import_types25.EdgeType.CALLS,
+            type: import_types28.EdgeType.CALLS,
             confidence,
             confidenceKind: "verified-call-site",
             evidence: ev
           });
           continue;
         }
-        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, match.routeNodeId, import_types25.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, match.routeNodeId, import_types28.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: match.routeNodeId,
-            type: import_types25.EdgeType.CALLS,
-            provenance: import_types25.Provenance.EXTRACTED,
+            type: import_types28.EdgeType.CALLS,
+            provenance: import_types28.Provenance.EXTRACTED,
             confidence,
             evidence: ev
           };
@@ -10341,8 +10808,8 @@ async function addRouteCallEdges(graph, services) {
 
 // src/extract/calls/kafka.ts
 init_cjs_shims();
-var import_node_path37 = __toESM(require("path"), 1);
-var import_types26 = require("@neat.is/types");
+var import_node_path40 = __toESM(require("path"), 1);
+var import_types29 = require("@neat.is/types");
 var PRODUCER_TOPIC_RE = /(?:producer|kafkaProducer)[\s\S]{0,40}?\.send\s*\(\s*\{[\s\S]{0,200}?topic\s*:\s*['"`]([^'"`]+)['"`]/g;
 var CONSUMER_TOPIC_RE = /(?:consumer|kafkaConsumer)[\s\S]{0,40}?\.(?:subscribe|run)\s*\(\s*\{[\s\S]{0,200}?topic[s]?\s*:\s*(?:\[\s*)?['"`]([^'"`]+)['"`]/g;
 function findAll(re, text) {
@@ -10363,7 +10830,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, topic);
     out.push({
-      infraId: (0, import_types26.infraId)("kafka-topic", topic),
+      infraId: (0, import_types29.infraId)("kafka-topic", topic),
       name: topic,
       kind: "kafka-topic",
       edgeType,
@@ -10372,7 +10839,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path37.default.relative(serviceDir, file.path),
+        file: import_node_path40.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10385,8 +10852,8 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/redis.ts
 init_cjs_shims();
-var import_node_path38 = __toESM(require("path"), 1);
-var import_types27 = require("@neat.is/types");
+var import_node_path41 = __toESM(require("path"), 1);
+var import_types30 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
   const out = [];
@@ -10399,7 +10866,7 @@ function redisEndpointsFromFile(file, serviceDir) {
     seen.add(host);
     const line = lineOf(file.content, host);
     out.push({
-      infraId: (0, import_types27.infraId)("redis", host),
+      infraId: (0, import_types30.infraId)("redis", host),
       name: host,
       kind: "redis",
       edgeType: "CALLS",
@@ -10408,7 +10875,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: import_node_path38.default.relative(serviceDir, file.path),
+        file: import_node_path41.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10419,8 +10886,8 @@ function redisEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/aws.ts
 init_cjs_shims();
-var import_node_path39 = __toESM(require("path"), 1);
-var import_types28 = require("@neat.is/types");
+var import_node_path42 = __toESM(require("path"), 1);
+var import_types31 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
 function hasMarker(text, markers) {
@@ -10444,7 +10911,7 @@ function awsEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, name);
     out.push({
-      infraId: (0, import_types28.infraId)(kind, name),
+      infraId: (0, import_types31.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -10453,7 +10920,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path39.default.relative(serviceDir, file.path),
+        file: import_node_path42.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10478,8 +10945,8 @@ function awsEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/grpc.ts
 init_cjs_shims();
-var import_node_path40 = __toESM(require("path"), 1);
-var import_types29 = require("@neat.is/types");
+var import_node_path43 = __toESM(require("path"), 1);
+var import_types32 = require("@neat.is/types");
 var GRPC_CLIENT_RE = /new\s+([A-Z][A-Za-z0-9_]*)Client\s*\(\s*['"`]?([^,'"`)]+)?/g;
 var AWS_SDK_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@aws-sdk\/client-([a-z0-9-]+)['"`]/g;
 var GRPC_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@grpc\/grpc-js['"`]|_grpc_pb['"`]/;
@@ -10528,7 +10995,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
     const { kind } = classified;
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types29.infraId)(kind, name),
+      infraId: (0, import_types32.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -10537,7 +11004,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path40.default.relative(serviceDir, file.path),
+        file: import_node_path43.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10548,8 +11015,8 @@ function grpcEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/supabase.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
-var import_types30 = require("@neat.is/types");
+var import_node_path44 = __toESM(require("path"), 1);
+var import_types33 = require("@neat.is/types");
 var SUPABASE_JS_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@supabase\/supabase-js['"`]/;
 var SUPABASE_SSR_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@supabase\/ssr['"`]/;
 var SUPABASE_CLIENT_RE = /\b(createClient|createServerClient|createBrowserClient)\s*\(\s*(?:['"`]([^'"`]*)['"`])?/g;
@@ -10597,7 +11064,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
     seen.add(name);
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types30.infraId)("supabase", name),
+      infraId: (0, import_types33.infraId)("supabase", name),
       name,
       kind: "supabase",
       edgeType: "CALLS",
@@ -10607,7 +11074,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_path41.default.relative(serviceDir, file.path),
+        file: import_node_path44.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10628,13 +11095,13 @@ function supabaseEndpointsFromFile(file, serviceDir) {
       seen.add(key);
       const line = lineOf(file.content, am[0]);
       out.push({
-        infraId: (0, import_types30.infraId)(kind, resource),
+        infraId: (0, import_types33.infraId)(kind, resource),
         name: resource,
         kind,
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: import_node_path41.default.relative(serviceDir, file.path),
+          file: import_node_path44.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -10646,10 +11113,10 @@ function supabaseEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/firestore.ts
 init_cjs_shims();
-var import_node_path42 = __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_types31 = require("@neat.is/types");
+var import_types34 = require("@neat.is/types");
 var FIRESTORE_CLIENT_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])firebase\/firestore['"`]/;
 var FIRESTORE_ADMIN_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])firebase-admin(?:\/firestore)?['"`]/;
 function parserForExt2(ext) {
@@ -10817,7 +11284,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
   const hasAdmin = FIRESTORE_ADMIN_IMPORT_RE.test(file.content);
   if (!hasClient && !hasAdmin) return [];
   const fileSdk = hasClient && !hasAdmin ? "client" : hasAdmin && !hasClient ? "admin" : null;
-  const tree = parseSource3(parserForExt2(import_node_path42.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt2(import_node_path45.default.extname(file.path)), file.content);
   const clientVars = firestoreClientVars(tree.rootNode);
   const collLine = /* @__PURE__ */ new Map();
   const writes = /* @__PURE__ */ new Map();
@@ -10910,7 +11377,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
       }
     }
     out.push({
-      infraId: (0, import_types31.infraId)("firestore-collection", collPath),
+      infraId: (0, import_types34.infraId)("firestore-collection", collPath),
       name: collPath,
       kind: "firestore-collection",
       edgeType: "CALLS",
@@ -10921,7 +11388,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
       ...columnSet.size > 0 ? { columns: [...columnSet] } : {},
       ...sdkWrites ? { sdkWrites } : {},
       evidence: {
-        file: import_node_path42.default.relative(serviceDir, file.path),
+        file: import_node_path45.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10932,8 +11399,8 @@ function firestoreEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/mongoose.ts
 init_cjs_shims();
-var import_node_path43 = __toESM(require("path"), 1);
-var import_types32 = require("@neat.is/types");
+var import_node_path46 = __toESM(require("path"), 1);
+var import_types35 = require("@neat.is/types");
 var MONGOOSE_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongoose['"`]/;
 var MONGODB_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongodb['"`]/;
 var PLURALIZE_DISABLED_RE = /\bpluralize\s*\(\s*(?:null|false)\s*\)/;
@@ -11078,12 +11545,12 @@ function collectModelDefs(content, pluralizeOn) {
 function endpoint(r, file, serviceDir, matchText) {
   const line = lineOf(file.content, matchText);
   return {
-    infraId: (0, import_types32.infraId)(r.kind, r.name),
+    infraId: (0, import_types35.infraId)(r.kind, r.name),
     name: r.name,
     kind: r.kind,
     edgeType: "CALLS",
     confidenceKind: "verified-call-site",
-    evidence: { file: import_node_path43.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) {
@@ -11173,7 +11640,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_path43.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 = [];
@@ -11184,7 +11651,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_path43.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;
@@ -11228,10 +11695,10 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/sqlalchemy.ts
 init_cjs_shims();
-var import_node_path44 = __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_types33 = require("@neat.is/types");
+var import_types36 = require("@neat.is/types");
 var SQLALCHEMY_IMPORT_RE = /(?:from|import)\s+(?:flask_sqlalchemy|sqlalchemy)\b/;
 var PARSE_CHUNK6 = 16384;
 function makePyParser3() {
@@ -11367,7 +11834,7 @@ function sqlalchemyForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path44.default.relative(serviceDir, file.path),
+          file: import_node_path47.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -11385,14 +11852,14 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
     if (seen.has(name)) return;
     seen.add(name);
     out.push({
-      infraId: (0, import_types33.infraId)("sql-table", name),
+      infraId: (0, import_types36.infraId)("sql-table", name),
       name,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       ...columns && columns.length > 0 ? { columns } : {},
       evidence: {
-        file: import_node_path44.default.relative(serviceDir, file.path),
+        file: import_node_path47.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11493,13 +11960,13 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
       if (seen.has(key)) continue;
       seen.add(key);
       out.push({
-        infraId: (0, import_types33.infraId)("sql-table", t),
+        infraId: (0, import_types36.infraId)("sql-table", t),
         name: t,
         kind: "sql-table",
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: import_node_path44.default.relative(serviceDir, file.path),
+          file: import_node_path47.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -11511,10 +11978,10 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/django-orm.ts
 init_cjs_shims();
-var import_node_path45 = __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_types34 = require("@neat.is/types");
+var import_types37 = require("@neat.is/types");
 var DJANGO_IMPORT_RE = /(?:from|import)\s+django\b/;
 var PARSE_CHUNK7 = 16384;
 function makePyParser4() {
@@ -11581,7 +12048,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
   const tree = parseSource7(makePyParser4(), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const defaultAppLabel = import_node_path45.default.basename(import_node_path45.default.dirname(file.path));
+  const defaultAppLabel = import_node_path48.default.basename(import_node_path48.default.dirname(file.path));
   walk4(tree.rootNode, (node) => {
     if (node.type !== "class_definition") return;
     if (!extendsDjangoModel(node)) return;
@@ -11594,12 +12061,12 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types34.infraId)("sql-table", table),
+      infraId: (0, import_types37.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       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_path48.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
     });
   });
   return out;
@@ -11607,10 +12074,10 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/drizzle.ts
 init_cjs_shims();
-var import_node_path46 = __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_javascript7 = __toESM(require("tree-sitter-javascript"), 1);
-var import_types35 = require("@neat.is/types");
+var import_types38 = require("@neat.is/types");
 var DRIZZLE_IMPORT_RE = /drizzle-orm/;
 var TABLE_BUILDERS = /* @__PURE__ */ new Set(["pgTable", "mysqlTable", "sqliteTable"]);
 function parserForExt3(ext) {
@@ -11685,7 +12152,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path46.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path49.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk9 = (node) => {
@@ -11701,14 +12168,14 @@ function drizzleEndpointsFromFile(file, serviceDir) {
           const columns = columnsFromObject(obj);
           const line = node.startPosition.row + 1;
           out.push({
-            infraId: (0, import_types35.infraId)("sql-table", tableName),
+            infraId: (0, import_types38.infraId)("sql-table", tableName),
             name: tableName,
             kind: "sql-table",
             edgeType: "CALLS",
             confidenceKind: "structural",
             columns,
             evidence: {
-              file: import_node_path46.default.relative(serviceDir, file.path),
+              file: import_node_path49.default.relative(serviceDir, file.path),
               line,
               snippet: snippet(file.content, line)
             }
@@ -11774,7 +12241,7 @@ function referencesTargetVar(call) {
 }
 function drizzleForeignKeys(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path46.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path49.default.extname(file.path)), file.content);
   const { tables, varToTable } = collectDrizzleTables(tree.rootNode);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -11793,7 +12260,7 @@ function drizzleForeignKeys(file, serviceDir) {
               childTable: table.tableName,
               parentTable,
               evidence: {
-                file: import_node_path46.default.relative(serviceDir, file.path),
+                file: import_node_path49.default.relative(serviceDir, file.path),
                 line,
                 snippet: snippet(file.content, line)
               }
@@ -11810,8 +12277,8 @@ function drizzleForeignKeys(file, serviceDir) {
 
 // src/extract/calls/prisma.ts
 init_cjs_shims();
-var import_node_path47 = __toESM(require("path"), 1);
-var import_types36 = require("@neat.is/types");
+var import_node_path50 = __toESM(require("path"), 1);
+var import_types39 = require("@neat.is/types");
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
   "String",
@@ -11859,14 +12326,14 @@ function prismaColumnsFromSchema(file, serviceDir) {
     if (seenTable.has(b.tableName)) return;
     seenTable.add(b.tableName);
     out.push({
-      infraId: (0, import_types36.infraId)("sql-table", b.tableName),
+      infraId: (0, import_types39.infraId)("sql-table", b.tableName),
       name: b.tableName,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "structural",
       columns: b.columns,
       evidence: {
-        file: import_node_path47.default.relative(serviceDir, file.path),
+        file: import_node_path50.default.relative(serviceDir, file.path),
         line: b.startLine,
         snippet: snippet(content, b.startLine)
       }
@@ -11927,7 +12394,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
 }
 async function prismaColumnEndpoints(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path47.default.join("prisma", "schema.prisma"),
+    import_node_path50.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -12002,7 +12469,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
               childTable: current.table,
               parentTable,
               evidence: {
-                file: import_node_path47.default.relative(serviceDir, file.path),
+                file: import_node_path50.default.relative(serviceDir, file.path),
                 line: lineNo,
                 snippet: snippet(content, lineNo)
               }
@@ -12017,7 +12484,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
 }
 async function prismaForeignKeys(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path47.default.join("prisma", "schema.prisma"),
+    import_node_path50.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -12028,10 +12495,10 @@ async function prismaForeignKeys(serviceDir) {
 
 // src/extract/calls/activerecord.ts
 init_cjs_shims();
-var import_node_path48 = __toESM(require("path"), 1);
+var import_node_path51 = __toESM(require("path"), 1);
 var import_tree_sitter12 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_ruby3 = __toESM(require("tree-sitter-ruby"), 1);
-var import_types37 = require("@neat.is/types");
+var import_types40 = require("@neat.is/types");
 var AR_SCHEMA_RE = /ActiveRecord::Schema/;
 var PARSE_CHUNK8 = 16384;
 function makeRubyParser2() {
@@ -12229,14 +12696,14 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
     if (!table || seen.has(table.name)) return;
     seen.add(table.name);
     out.push({
-      infraId: (0, import_types37.infraId)("sql-table", table.name),
+      infraId: (0, import_types40.infraId)("sql-table", table.name),
       name: table.name,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "structural",
       ...table.columns.length > 0 ? { columns: table.columns } : {},
       evidence: {
-        file: import_node_path48.default.relative(serviceDir, file.path),
+        file: import_node_path51.default.relative(serviceDir, file.path),
         line: table.line,
         snippet: snippet(file.content, table.line)
       }
@@ -12258,7 +12725,7 @@ function railsSchemaForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: import_node_path48.default.relative(serviceDir, file.path),
+        file: import_node_path51.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12335,13 +12802,13 @@ function railsModelEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types37.infraId)("sql-table", table),
+      infraId: (0, import_types40.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path48.default.relative(serviceDir, file.path),
+        file: import_node_path51.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12378,7 +12845,7 @@ function railsModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path48.default.relative(serviceDir, file.path),
+          file: import_node_path51.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -12390,10 +12857,10 @@ function railsModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/eloquent.ts
 init_cjs_shims();
-var import_node_path49 = __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_php3 = __toESM(require("tree-sitter-php"), 1);
-var import_types38 = require("@neat.is/types");
+var import_types41 = require("@neat.is/types");
 var LARAVEL_SCHEMA_RE = /\bSchema::(create|createIfNotExists|table)\b/;
 var PARSE_CHUNK9 = 16384;
 function makePhpParser2() {
@@ -12640,14 +13107,14 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       }
     }
     out.push({
-      infraId: (0, import_types38.infraId)("sql-table", bp.table),
+      infraId: (0, import_types41.infraId)("sql-table", bp.table),
       name: bp.table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: import_node_path49.default.relative(serviceDir, file.path),
+        file: import_node_path52.default.relative(serviceDir, file.path),
         line: bp.line,
         snippet: snippet(file.content, bp.line)
       }
@@ -12669,7 +13136,7 @@ function laravelMigrationForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: import_node_path49.default.relative(serviceDir, file.path),
+        file: import_node_path52.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12783,13 +13250,13 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types38.infraId)("sql-table", table),
+      infraId: (0, import_types41.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path49.default.relative(serviceDir, file.path),
+        file: import_node_path52.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12825,7 +13292,7 @@ function laravelModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path49.default.relative(serviceDir, file.path),
+          file: import_node_path52.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -12837,10 +13304,10 @@ function laravelModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/go.ts
 init_cjs_shims();
-var import_node_path52 = __toESM(require("path"), 1);
+var import_node_path55 = __toESM(require("path"), 1);
 var import_tree_sitter14 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_go4 = __toESM(require("tree-sitter-go"), 1);
-var import_types39 = require("@neat.is/types");
+var import_types42 = require("@neat.is/types");
 init_otel();
 var PARSE_CHUNK10 = 16384;
 var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
@@ -12912,7 +13379,7 @@ function firstStringLiteralArg(argsNode) {
   return null;
 }
 function goSqlEndpointsFromFile(file, serviceDir) {
-  if (import_node_path52.default.extname(file.path) !== ".go") return [];
+  if (import_node_path55.default.extname(file.path) !== ".go") return [];
   if (!file.content.includes(DATABASE_SQL_IMPORT) && !file.content.includes(SQLX_IMPORT)) return [];
   const tree = parseSource10(makeGoParser3(), file.content);
   const importsDatabaseSql = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([DATABASE_SQL_IMPORT]));
@@ -12934,14 +13401,14 @@ function goSqlEndpointsFromFile(file, serviceDir) {
     const columns = columnsFromSqlStatement(sql);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types39.infraId)("sql-table", table),
+      infraId: (0, import_types42.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path52.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path55.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12952,10 +13419,10 @@ function goSqlEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/gorm.ts
 init_cjs_shims();
-var import_node_path53 = __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_go5 = __toESM(require("tree-sitter-go"), 1);
-var import_types40 = require("@neat.is/types");
+var import_types43 = require("@neat.is/types");
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK11 = 16384;
 function makeGoParser4() {
@@ -13385,7 +13852,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
   seen.delete(struct.name);
 }
 function gormEndpointsFromFile(file, serviceDir) {
-  if (import_node_path53.default.extname(file.path) !== ".go") return [];
+  if (import_node_path56.default.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
   const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
@@ -13400,14 +13867,14 @@ function gormEndpointsFromFile(file, serviceDir) {
     const columns = [];
     collectColumns(struct, structs, /* @__PURE__ */ new Set(), "", columns, /* @__PURE__ */ new Set());
     out.push({
-      infraId: (0, import_types40.infraId)("sql-table", table),
+      infraId: (0, import_types43.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path53.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path56.default.relative(serviceDir, file.path)),
         line: struct.line,
         snippet: snippet(file.content, struct.line)
       }
@@ -13416,7 +13883,7 @@ function gormEndpointsFromFile(file, serviceDir) {
   return out;
 }
 function gormForeignKeys(file, serviceDir) {
-  if (import_node_path53.default.extname(file.path) !== ".go") return [];
+  if (import_node_path56.default.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
   const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
@@ -13431,7 +13898,7 @@ function gormForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: toPosix(import_node_path53.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path56.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13470,11 +13937,11 @@ function gormForeignKeys(file, serviceDir) {
 function edgeTypeFromEndpoint(ep) {
   switch (ep.edgeType) {
     case "PUBLISHES_TO":
-      return import_types41.EdgeType.PUBLISHES_TO;
+      return import_types44.EdgeType.PUBLISHES_TO;
     case "CONSUMES_FROM":
-      return import_types41.EdgeType.CONSUMES_FROM;
+      return import_types44.EdgeType.CONSUMES_FROM;
     default:
-      return import_types41.EdgeType.CALLS;
+      return import_types44.EdgeType.CALLS;
   }
 }
 function isAwsKind(kind) {
@@ -13484,7 +13951,7 @@ async function addExternalEndpointEdges(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     const endpoints = [];
     const maskedFiles = [];
     for (const file of files) {
@@ -13534,7 +14001,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: import_types41.NodeType.InfraNode,
+          type: import_types44.NodeType.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -13547,21 +14014,21 @@ async function addExternalEndpointEdges(graph, services) {
       }
       if (ep.columns && ep.columns.length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === import_types41.NodeType.InfraNode) {
+        if (node.type === import_types44.NodeType.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldColumns(
               node.columns,
               ep.columns,
-              import_types41.Provenance.EXTRACTED,
-              (0, import_types41.confidenceForExtracted)(ep.confidenceKind)
+              import_types44.Provenance.EXTRACTED,
+              (0, import_types44.confidenceForExtracted)(ep.confidenceKind)
             )
           });
         }
       }
       if (ep.sdkWrites && Object.keys(ep.sdkWrites).length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === import_types41.NodeType.InfraNode) {
+        if (node.type === import_types44.NodeType.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldSdkWrites(node.columns, ep.sdkWrites)
@@ -13569,7 +14036,7 @@ async function addExternalEndpointEdges(graph, services) {
         }
       }
       const edgeType = edgeTypeFromEndpoint(ep);
-      const confidence = (0, import_types41.confidenceForExtracted)(ep.confidenceKind);
+      const confidence = (0, import_types44.confidenceForExtracted)(ep.confidenceKind);
       const relFile = toPosix(ep.evidence.file);
       const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
@@ -13579,7 +14046,7 @@ async function addExternalEndpointEdges(graph, services) {
       );
       nodesAdded += n;
       edgesAdded += e;
-      if (!(0, import_types41.passesExtractedFloor)(confidence)) {
+      if (!(0, import_types44.passesExtractedFloor)(confidence)) {
         noteExtractedDropped({
           source: fileNodeId,
           target: ep.infraId,
@@ -13599,7 +14066,7 @@ async function addExternalEndpointEdges(graph, services) {
           source: fileNodeId,
           target: ep.infraId,
           type: edgeType,
-          provenance: import_types41.Provenance.EXTRACTED,
+          provenance: import_types44.Provenance.EXTRACTED,
           confidence,
           evidence: ep.evidence
         };
@@ -13622,12 +14089,12 @@ async function addCallEdges(graph, services) {
 
 // src/extract/table-edges.ts
 init_cjs_shims();
-var import_types42 = require("@neat.is/types");
+var import_types45 = require("@neat.is/types");
 async function addTableEdges(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     const refs = [];
     const modelRefs = [];
     for (const file of files) {
@@ -13650,20 +14117,20 @@ async function addTableEdges(graph, services) {
     }
     refs.push(...modelRefs);
     for (const ref of refs) {
-      const childId = (0, import_types42.infraId)("sql-table", ref.childTable);
-      const parentId = (0, import_types42.infraId)("sql-table", ref.parentTable);
+      const childId = (0, import_types45.infraId)("sql-table", ref.childTable);
+      const parentId = (0, import_types45.infraId)("sql-table", ref.parentTable);
       if (childId === parentId) continue;
       nodesAdded += ensureTableNode(graph, childId, ref.childTable);
       nodesAdded += ensureTableNode(graph, parentId, ref.parentTable);
-      const edgeId = (0, import_types42.extractedEdgeId)(childId, parentId, import_types42.EdgeType.REFERENCES);
+      const edgeId = (0, import_types45.extractedEdgeId)(childId, parentId, import_types45.EdgeType.REFERENCES);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: childId,
         target: parentId,
-        type: import_types42.EdgeType.REFERENCES,
-        provenance: import_types42.Provenance.EXTRACTED,
-        confidence: (0, import_types42.confidenceForExtracted)("structural"),
+        type: import_types45.EdgeType.REFERENCES,
+        provenance: import_types45.Provenance.EXTRACTED,
+        confidence: (0, import_types45.confidenceForExtracted)("structural"),
         evidence: ref.evidence
       };
       graph.addEdgeWithKey(edgeId, childId, parentId, edge);
@@ -13676,7 +14143,7 @@ function ensureTableNode(graph, id, name) {
   if (graph.hasNode(id)) return 0;
   const node = {
     id,
-    type: import_types42.NodeType.InfraNode,
+    type: import_types45.NodeType.InfraNode,
     name,
     provider: "self",
     kind: "sql-table"
@@ -13690,16 +14157,16 @@ init_cjs_shims();
 
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
-var import_node_path54 = __toESM(require("path"), 1);
-var import_types44 = require("@neat.is/types");
+var import_node_path57 = __toESM(require("path"), 1);
+var import_types47 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
 init_cjs_shims();
-var import_types43 = require("@neat.is/types");
+var import_types46 = require("@neat.is/types");
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
-    id: (0, import_types43.infraId)(kind, name),
-    type: import_types43.NodeType.InfraNode,
+    id: (0, import_types46.infraId)(kind, name),
+    type: import_types46.NodeType.InfraNode,
     name,
     provider,
     kind,
@@ -13743,8 +14210,8 @@ function emitPlatformResourceEdge(graph, anchorId, edgeType, kind, name, provide
       source: anchorId,
       target: node.id,
       type: edgeType,
-      provenance: import_types43.Provenance.EXTRACTED,
-      confidence: (0, import_types43.confidenceForExtracted)("structural"),
+      provenance: import_types46.Provenance.EXTRACTED,
+      confidence: (0, import_types46.confidenceForExtracted)("structural"),
       evidence: { file: evidenceFile, ...line !== void 0 ? { line } : {} }
     };
     graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13761,7 +14228,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || import_node_path54.default.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || import_node_path57.default.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -13770,7 +14237,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_path54.default.join(scanPath, name);
+    const abs = import_node_path57.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -13783,13 +14250,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      import_node_path54.default.relative(scanPath, composePath),
+      import_node_path57.default.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = import_node_path54.default.relative(scanPath, composePath).split(import_node_path54.default.sep).join("/");
+  const evidenceFile = import_node_path57.default.relative(scanPath, composePath).split(import_node_path57.default.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -13811,15 +14278,15 @@ async function addComposeInfra(graph, scanPath, services) {
     for (const dep of dependsOnList(svc.depends_on)) {
       const targetId = composeNameToNodeId.get(dep);
       if (!targetId) continue;
-      const edgeId = (0, import_types3.extractedEdgeId)(sourceId, targetId, import_types44.EdgeType.DEPENDS_ON);
+      const edgeId = (0, import_types3.extractedEdgeId)(sourceId, targetId, import_types47.EdgeType.DEPENDS_ON);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: sourceId,
         target: targetId,
-        type: import_types44.EdgeType.DEPENDS_ON,
-        provenance: import_types44.Provenance.EXTRACTED,
-        confidence: (0, import_types44.confidenceForExtracted)("structural"),
+        type: import_types47.EdgeType.DEPENDS_ON,
+        provenance: import_types47.Provenance.EXTRACTED,
+        confidence: (0, import_types47.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13831,9 +14298,9 @@ async function addComposeInfra(graph, scanPath, services) {
 
 // src/extract/infra/dockerfile.ts
 init_cjs_shims();
-var import_node_path55 = __toESM(require("path"), 1);
-var import_node_fs23 = require("fs");
-var import_types45 = require("@neat.is/types");
+var import_node_path58 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
+var import_types48 = require("@neat.is/types");
 function readDockerfile(content) {
   let image = null;
   const ports = [];
@@ -13862,15 +14329,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = import_node_path55.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path58.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs23.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs26.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        import_node_path55.default.relative(scanPath, dockerfilePath),
+        import_node_path58.default.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -13882,8 +14349,8 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix(import_node_path55.default.relative(service.dir, dockerfilePath));
-    const evidenceFile = toPosix(import_node_path55.default.relative(scanPath, dockerfilePath));
+    const relDockerfile = toPosix(import_node_path58.default.relative(service.dir, dockerfilePath));
+    const evidenceFile = toPosix(import_node_path58.default.relative(scanPath, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -13892,15 +14359,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
     );
     nodesAdded += fn;
     edgesAdded += fe;
-    const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types45.EdgeType.RUNS_ON);
+    const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types48.EdgeType.RUNS_ON);
     if (!graph.hasEdge(edgeId)) {
       const edge = {
         id: edgeId,
         source: fileNodeId,
         target: node.id,
-        type: import_types45.EdgeType.RUNS_ON,
-        provenance: import_types45.Provenance.EXTRACTED,
-        confidence: (0, import_types45.confidenceForExtracted)("structural"),
+        type: import_types48.EdgeType.RUNS_ON,
+        provenance: import_types48.Provenance.EXTRACTED,
+        confidence: (0, import_types48.confidenceForExtracted)("structural"),
         evidence: {
           file: evidenceFile,
           ...facts.entrypoint ? { snippet: facts.entrypoint.slice(0, 120) } : {}
@@ -13915,15 +14382,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
         graph.addNode(portNode.id, portNode);
         nodesAdded++;
       }
-      const portEdgeId = (0, import_types3.extractedEdgeId)(fileNodeId, portNode.id, import_types45.EdgeType.CONNECTS_TO);
+      const portEdgeId = (0, import_types3.extractedEdgeId)(fileNodeId, portNode.id, import_types48.EdgeType.CONNECTS_TO);
       if (graph.hasEdge(portEdgeId)) continue;
       const portEdge = {
         id: portEdgeId,
         source: fileNodeId,
         target: portNode.id,
-        type: import_types45.EdgeType.CONNECTS_TO,
-        provenance: import_types45.Provenance.EXTRACTED,
-        confidence: (0, import_types45.confidenceForExtracted)("structural"),
+        type: import_types48.EdgeType.CONNECTS_TO,
+        provenance: import_types48.Provenance.EXTRACTED,
+        confidence: (0, import_types48.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile, snippet: `EXPOSE ${port}` }
       };
       graph.addEdgeWithKey(portEdgeId, portEdge.source, portEdge.target, portEdge);
@@ -13935,23 +14402,23 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 
 // src/extract/infra/terraform.ts
 init_cjs_shims();
-var import_node_fs24 = require("fs");
-var import_node_path56 = __toESM(require("path"), 1);
-var import_types46 = require("@neat.is/types");
+var import_node_fs27 = require("fs");
+var import_node_path59 = __toESM(require("path"), 1);
+var import_types49 = 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_fs24.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs27.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name) || entry.name === ".terraform") continue;
-      const child = import_node_path56.default.join(start, entry.name);
+      const child = import_node_path59.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkTfFiles(child, depth + 1, max));
     } else if (entry.isFile() && entry.name.endsWith(".tf")) {
-      out.push(import_node_path56.default.join(start, entry.name));
+      out.push(import_node_path59.default.join(start, entry.name));
     }
   }
   return out;
@@ -13982,8 +14449,8 @@ async function addTerraformResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs24.promises.readFile(file, "utf8");
-    const evidenceFile = toPosix(import_node_path56.default.relative(scanPath, file));
+    const content = await import_node_fs27.promises.readFile(file, "utf8");
+    const evidenceFile = toPosix(import_node_path59.default.relative(scanPath, file));
     const resources = [];
     const byKey = /* @__PURE__ */ new Map();
     RESOURCE_RE.lastIndex = 0;
@@ -14018,16 +14485,16 @@ async function addTerraformResources(graph, scanPath) {
         if (!target) continue;
         if (seen.has(target.nodeId)) continue;
         seen.add(target.nodeId);
-        const edgeId = (0, import_types3.extractedEdgeId)(resource.nodeId, target.nodeId, import_types46.EdgeType.DEPENDS_ON);
+        const edgeId = (0, import_types3.extractedEdgeId)(resource.nodeId, target.nodeId, import_types49.EdgeType.DEPENDS_ON);
         if (graph.hasEdge(edgeId)) continue;
         const line = lineAt2(content, resource.bodyOffset + ref.index);
         const edge = {
           id: edgeId,
           source: resource.nodeId,
           target: target.nodeId,
-          type: import_types46.EdgeType.DEPENDS_ON,
-          provenance: import_types46.Provenance.EXTRACTED,
-          confidence: (0, import_types46.confidenceForExtracted)("structural"),
+          type: import_types49.EdgeType.DEPENDS_ON,
+          provenance: import_types49.Provenance.EXTRACTED,
+          confidence: (0, import_types49.confidenceForExtracted)("structural"),
           evidence: { file: evidenceFile, line, snippet: key }
         };
         graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -14040,8 +14507,8 @@ async function addTerraformResources(graph, scanPath) {
 
 // src/extract/infra/k8s.ts
 init_cjs_shims();
-var import_node_fs25 = require("fs");
-var import_node_path57 = __toESM(require("path"), 1);
+var import_node_fs28 = require("fs");
+var import_node_path60 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var K8S_KIND_TO_INFRA_KIND = {
   Service: "k8s-service",
@@ -14055,15 +14522,15 @@ var K8S_KIND_TO_INFRA_KIND = {
 async function walkYamlFiles2(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await import_node_fs25.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs28.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path57.default.join(start, entry.name);
+      const child = import_node_path60.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles2(child, depth + 1, max));
-    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path57.default.extname(entry.name))) {
-      out.push(import_node_path57.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path60.default.extname(entry.name))) {
+      out.push(import_node_path60.default.join(start, entry.name));
     }
   }
   return out;
@@ -14072,7 +14539,7 @@ async function addK8sResources(graph, scanPath) {
   let nodesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await import_node_fs25.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());
@@ -14096,17 +14563,17 @@ async function addK8sResources(graph, scanPath) {
 
 // src/extract/infra/cloudflare.ts
 init_cjs_shims();
-var import_node_fs26 = require("fs");
-var import_node_path58 = __toESM(require("path"), 1);
-var import_smol_toml2 = require("smol-toml");
-var import_types47 = require("@neat.is/types");
+var import_node_fs29 = require("fs");
+var import_node_path61 = __toESM(require("path"), 1);
+var import_smol_toml3 = require("smol-toml");
+var import_types50 = 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_path58.default.join(dir, filename);
+    const abs = import_node_path61.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs26.promises.readFile(abs, "utf8");
-    const config = filename === "wrangler.toml" ? (0, import_smol_toml2.parse)(raw) : JSON.parse(maskCommentsInSource(raw));
+    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 };
   }
   return null;
@@ -14147,8 +14614,8 @@ function addResourceEdge(graph, anchorId, edgeType, kind, name, evidenceFile, li
       source: anchorId,
       target: node.id,
       type: edgeType,
-      provenance: import_types47.Provenance.EXTRACTED,
-      confidence: (0, import_types47.confidenceForExtracted)("structural"),
+      provenance: import_types50.Provenance.EXTRACTED,
+      confidence: (0, import_types50.confidenceForExtracted)("structural"),
       evidence: { file: evidenceFile, ...line !== void 0 ? { line } : {} }
     };
     graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -14166,11 +14633,11 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     try {
       read = await readWranglerConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra cloudflare", import_node_path58.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra cloudflare", import_node_path61.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read || !read.config.name) continue;
-    const evidenceFile = toPosix(import_node_path58.default.relative(scanPath, import_node_path58.default.join(service.dir, read.relFile)));
+    const evidenceFile = toPosix(import_node_path61.default.relative(scanPath, import_node_path61.default.join(service.dir, read.relFile)));
     discovered.push({ service, config: read.config, relFile: read.relFile, raw: read.raw, evidenceFile });
   }
   for (const worker of discovered) {
@@ -14182,7 +14649,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     }
     let anchorId = service.node.id;
     if (config.main) {
-      const entryRelPath = toPosix(import_node_path58.default.normalize(config.main));
+      const entryRelPath = toPosix(import_node_path61.default.normalize(config.main));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -14209,15 +14676,15 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       nodesAdded++;
     }
     if (runtimeNode.id !== anchorId) {
-      const runsOnId = (0, import_types3.extractedEdgeId)(anchorId, runtimeNode.id, import_types47.EdgeType.RUNS_ON);
+      const runsOnId = (0, import_types3.extractedEdgeId)(anchorId, runtimeNode.id, import_types50.EdgeType.RUNS_ON);
       if (!graph.hasEdge(runsOnId)) {
         const edge = {
           id: runsOnId,
           source: anchorId,
           target: runtimeNode.id,
-          type: import_types47.EdgeType.RUNS_ON,
-          provenance: import_types47.Provenance.EXTRACTED,
-          confidence: (0, import_types47.confidenceForExtracted)("structural"),
+          type: import_types50.EdgeType.RUNS_ON,
+          provenance: import_types50.Provenance.EXTRACTED,
+          confidence: (0, import_types50.confidenceForExtracted)("structural"),
           evidence: {
             file: evidenceFile,
             ...config.compatibility_date ? { snippet: `compatibility_date = ${config.compatibility_date}`.slice(0, 120) } : {}
@@ -14231,7 +14698,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types47.EdgeType.CONNECTS_TO,
+        import_types50.EdgeType.CONNECTS_TO,
         "cloudflare-route",
         route,
         evidenceFile,
@@ -14255,7 +14722,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
         const result = addResourceEdge(
           graph,
           anchorId,
-          import_types47.EdgeType.DEPENDS_ON,
+          import_types50.EdgeType.DEPENDS_ON,
           group.kind,
           name,
           evidenceFile,
@@ -14269,7 +14736,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types47.EdgeType.DEPENDS_ON,
+        import_types50.EdgeType.DEPENDS_ON,
         "cloudflare-cron",
         cron,
         evidenceFile,
@@ -14282,7 +14749,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types47.EdgeType.DEPENDS_ON,
+        import_types50.EdgeType.DEPENDS_ON,
         "cloudflare-env-var",
         varName,
         evidenceFile,
@@ -14295,15 +14762,15 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       if (!svc.service) continue;
       const target = workerIndex.get(svc.service);
       if (target && target.anchorId !== anchorId) {
-        const edgeId = (0, import_types3.extractedEdgeId)(anchorId, target.anchorId, import_types47.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(anchorId, target.anchorId, import_types50.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: anchorId,
             target: target.anchorId,
-            type: import_types47.EdgeType.CALLS,
-            provenance: import_types47.Provenance.EXTRACTED,
-            confidence: (0, import_types47.confidenceForExtracted)("structural"),
+            type: import_types50.EdgeType.CALLS,
+            provenance: import_types50.Provenance.EXTRACTED,
+            confidence: (0, import_types50.confidenceForExtracted)("structural"),
             evidence: { file: evidenceFile, line: lineContaining2(raw, svc.service) }
           };
           graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -14314,7 +14781,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types47.EdgeType.DEPENDS_ON,
+        import_types50.EdgeType.DEPENDS_ON,
         "cloudflare-service-binding",
         svc.service,
         evidenceFile,
@@ -14329,24 +14796,24 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 
 // src/extract/infra/vercel.ts
 init_cjs_shims();
-var import_node_fs27 = require("fs");
-var import_node_path59 = __toESM(require("path"), 1);
-var import_types48 = require("@neat.is/types");
+var import_node_fs30 = require("fs");
+var import_node_path62 = __toESM(require("path"), 1);
+var import_types51 = 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_path59.default.join(dir, filename);
+    const abs = import_node_path62.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs27.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_path59.default.join(dir, ".vercel", "project.json");
+  const abs = import_node_path62.default.join(dir, ".vercel", "project.json");
   if (!await exists2(abs)) return void 0;
-  const parsed = JSON.parse(await import_node_fs27.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) {
@@ -14362,7 +14829,7 @@ async function addVercelServices(graph, services, scanPath) {
       read = await readVercelConfig(service.dir);
       projectName = await readLinkedProjectName(service.dir);
     } catch (err) {
-      recordExtractionError("infra vercel", import_node_path59.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra vercel", import_node_path62.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read && !projectName) continue;
@@ -14378,7 +14845,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_path59.default.relative(scanPath, import_node_path59.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path62.default.relative(scanPath, import_node_path62.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -14394,12 +14861,12 @@ async function addVercelServices(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types48.EdgeType.RUNS_ON, "vercel", "vercel");
-    for (const cron of config.crons ?? []) add(import_types48.EdgeType.DEPENDS_ON, "vercel-cron", cron.path ?? cron.schedule);
-    for (const varName of Object.keys(config.env ?? {})) add(import_types48.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
-    for (const varName of Object.keys(config.build?.env ?? {})) add(import_types48.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
+    add(import_types51.EdgeType.RUNS_ON, "vercel", "vercel");
+    for (const cron of config.crons ?? []) add(import_types51.EdgeType.DEPENDS_ON, "vercel-cron", cron.path ?? cron.schedule);
+    for (const varName of Object.keys(config.env ?? {})) add(import_types51.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
+    for (const varName of Object.keys(config.build?.env ?? {})) add(import_types51.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
     for (const route of [...config.rewrites ?? [], ...config.redirects ?? [], ...config.routes ?? []]) {
-      add(import_types48.EdgeType.CONNECTS_TO, "vercel-route", routeSource(route));
+      add(import_types51.EdgeType.CONNECTS_TO, "vercel-route", routeSource(route));
     }
   }
   return { nodesAdded, edgesAdded };
@@ -14407,17 +14874,17 @@ async function addVercelServices(graph, services, scanPath) {
 
 // src/extract/infra/railway.ts
 init_cjs_shims();
-var import_node_fs28 = require("fs");
-var import_node_path60 = __toESM(require("path"), 1);
-var import_smol_toml3 = require("smol-toml");
-var import_types49 = require("@neat.is/types");
+var import_node_fs31 = require("fs");
+var import_node_path63 = __toESM(require("path"), 1);
+var import_smol_toml4 = require("smol-toml");
+var import_types52 = 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_path60.default.join(dir, filename);
+    const abs = import_node_path63.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs28.promises.readFile(abs, "utf8");
-    const config = filename === "railway.toml" ? (0, import_smol_toml3.parse)(raw) : JSON.parse(maskCommentsInSource(raw));
+    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 };
   }
   return null;
@@ -14430,7 +14897,7 @@ async function addRailwayServices(graph, services, scanPath) {
     try {
       read = await readRailwayConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra railway", import_node_path60.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra railway", import_node_path63.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -14440,7 +14907,7 @@ async function addRailwayServices(graph, services, scanPath) {
     }
     const anchorId = service.node.id;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(import_node_path60.default.relative(scanPath, import_node_path60.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path63.default.relative(scanPath, import_node_path63.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -14456,25 +14923,25 @@ async function addRailwayServices(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types49.EdgeType.RUNS_ON, "railway", "railway");
-    add(import_types49.EdgeType.CONNECTS_TO, "railway-route", config.deploy?.healthcheckPath);
-    add(import_types49.EdgeType.DEPENDS_ON, "railway-cron", config.deploy?.cronSchedule);
+    add(import_types52.EdgeType.RUNS_ON, "railway", "railway");
+    add(import_types52.EdgeType.CONNECTS_TO, "railway-route", config.deploy?.healthcheckPath);
+    add(import_types52.EdgeType.DEPENDS_ON, "railway-cron", config.deploy?.cronSchedule);
   }
   return { nodesAdded, edgesAdded };
 }
 
 // src/extract/infra/supabase.ts
 init_cjs_shims();
-var import_node_fs29 = require("fs");
-var import_node_path61 = __toESM(require("path"), 1);
-var import_smol_toml4 = require("smol-toml");
-var import_types50 = require("@neat.is/types");
+var import_node_fs32 = require("fs");
+var import_node_path64 = __toESM(require("path"), 1);
+var import_smol_toml5 = require("smol-toml");
+var import_types53 = require("@neat.is/types");
 async function readSupabaseConfig(dir) {
-  const relFile = import_node_path61.default.join("supabase", "config.toml");
-  const abs = import_node_path61.default.join(dir, relFile);
+  const relFile = import_node_path64.default.join("supabase", "config.toml");
+  const abs = import_node_path64.default.join(dir, relFile);
   if (!await exists2(abs)) return null;
-  const raw = await import_node_fs29.promises.readFile(abs, "utf8");
-  const config = (0, import_smol_toml4.parse)(raw);
+  const raw = await import_node_fs32.promises.readFile(abs, "utf8");
+  const config = (0, import_smol_toml5.parse)(raw);
   return { config, relFile, raw };
 }
 async function addSupabaseProjects(graph, services, scanPath) {
@@ -14485,7 +14952,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
     try {
       read = await readSupabaseConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra supabase", import_node_path61.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra supabase", import_node_path64.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -14500,7 +14967,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
       });
     }
     const anchorId = service.node.id;
-    const evidenceFile = toPosix(import_node_path61.default.relative(scanPath, import_node_path61.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(
@@ -14516,10 +14983,10 @@ async function addSupabaseProjects(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types50.EdgeType.RUNS_ON, "supabase", "supabase");
-    for (const fn of Object.keys(config.functions ?? {})) add(import_types50.EdgeType.DEPENDS_ON, "supabase-function", fn);
-    if (config.storage) add(import_types50.EdgeType.DEPENDS_ON, "supabase-storage", "storage");
-    if (config.auth) add(import_types50.EdgeType.DEPENDS_ON, "supabase-auth", "auth");
+    add(import_types53.EdgeType.RUNS_ON, "supabase", "supabase");
+    for (const fn of Object.keys(config.functions ?? {})) add(import_types53.EdgeType.DEPENDS_ON, "supabase-function", fn);
+    if (config.storage) add(import_types53.EdgeType.DEPENDS_ON, "supabase-storage", "storage");
+    if (config.auth) add(import_types53.EdgeType.DEPENDS_ON, "supabase-auth", "auth");
   }
   return { nodesAdded, edgesAdded };
 }
@@ -14542,10 +15009,10 @@ async function addInfra(graph, scanPath, services) {
 
 // src/extract/zod-shapes.ts
 init_cjs_shims();
-var import_node_path62 = __toESM(require("path"), 1);
+var import_node_path65 = __toESM(require("path"), 1);
 var import_tree_sitter16 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript8 = __toESM(require("tree-sitter-javascript"), 1);
-var import_types51 = require("@neat.is/types");
+var import_types54 = require("@neat.is/types");
 var ZOD_IMPORT_RE = /\bzod\b/;
 var ZOD_OBJECTS = /* @__PURE__ */ new Set(["z", "zod"]);
 function parserForExt4(ext) {
@@ -14637,7 +15104,7 @@ function topLevelSchemas(root) {
 }
 function zodShapesFromFile(file, serviceDir) {
   if (!ZOD_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt4(import_node_path62.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt4(import_node_path65.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const { name, call } of topLevelSchemas(tree.rootNode)) {
@@ -14651,11 +15118,11 @@ function zodShapesFromFile(file, serviceDir) {
     seen.add(name);
     const line = call.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types51.infraId)("zod-schema", name),
+      infraId: (0, import_types54.infraId)("zod-schema", name),
       name,
       fields,
       evidence: {
-        file: import_node_path62.default.relative(serviceDir, file.path),
+        file: import_node_path65.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14672,7 +15139,7 @@ async function addZodShapes(graph, services) {
       ...service.pkg.devDependencies ?? {}
     };
     if (deps["zod"] === void 0) continue;
-    const files = await loadSourceFiles(service.dir);
+    const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
       let shapes;
@@ -14686,7 +15153,7 @@ async function addZodShapes(graph, services) {
         if (!graph.hasNode(shape.infraId)) {
           const node = {
             id: shape.infraId,
-            type: import_types51.NodeType.InfraNode,
+            type: import_types54.NodeType.InfraNode,
             name: shape.name,
             provider: "self",
             kind: "zod-schema"
@@ -14696,14 +15163,14 @@ async function addZodShapes(graph, services) {
         }
         if (shape.fields.length > 0) {
           const node = graph.getNodeAttributes(shape.infraId);
-          if (node.type === import_types51.NodeType.InfraNode) {
+          if (node.type === import_types54.NodeType.InfraNode) {
             graph.replaceNodeAttributes(shape.infraId, {
               ...node,
               columns: foldColumns(
                 node.columns,
                 shape.fields,
-                import_types51.Provenance.EXTRACTED,
-                (0, import_types51.confidenceForExtracted)("structural")
+                import_types54.Provenance.EXTRACTED,
+                (0, import_types54.confidenceForExtracted)("structural")
               )
             });
           }
@@ -14717,15 +15184,15 @@ async function addZodShapes(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        const edgeId = (0, import_types51.extractedEdgeId)(fileNodeId, shape.infraId, import_types51.EdgeType.CONTAINS);
+        const edgeId = (0, import_types54.extractedEdgeId)(fileNodeId, shape.infraId, import_types54.EdgeType.CONTAINS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: shape.infraId,
-            type: import_types51.EdgeType.CONTAINS,
-            provenance: import_types51.Provenance.EXTRACTED,
-            confidence: (0, import_types51.confidenceForExtracted)("structural"),
+            type: import_types54.EdgeType.CONTAINS,
+            provenance: import_types54.Provenance.EXTRACTED,
+            confidence: (0, import_types54.confidenceForExtracted)("structural"),
             evidence: shape.evidence
           };
           graph.addEdgeWithKey(edgeId, fileNodeId, shape.infraId, edge);
@@ -14739,7 +15206,7 @@ async function addZodShapes(graph, services) {
 
 // src/extract/firestore-rules.ts
 init_cjs_shims();
-var import_types52 = require("@neat.is/types");
+var import_types55 = require("@neat.is/types");
 var FIRESTORE_COLLECTION_KIND = "firestore-collection";
 var WRITE_METHODS = /* @__PURE__ */ new Set(["write", "create", "update"]);
 function stripComments(src) {
@@ -14879,7 +15346,7 @@ async function addFirestoreRules(graph, services) {
   if (guards.size === 0) return { nodesAdded: 0, edgesAdded: 0 };
   graph.forEachNode((id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types52.NodeType.InfraNode) return;
+    if (node.type !== import_types55.NodeType.InfraNode) return;
     if (node.kind !== FIRESTORE_COLLECTION_KIND) return;
     const fields = guards.get(collectionKeyFromName(node.name));
     if (!fields || fields.size === 0) return;
@@ -14892,17 +15359,17 @@ async function addFirestoreRules(graph, services) {
 }
 
 // src/extract/index.ts
-var import_node_path64 = __toESM(require("path"), 1);
+var import_node_path67 = __toESM(require("path"), 1);
 
 // src/extract/retire.ts
 init_cjs_shims();
-var import_node_fs30 = require("fs");
-var import_node_path63 = __toESM(require("path"), 1);
-var import_types53 = require("@neat.is/types");
+var import_node_fs33 = require("fs");
+var import_node_path66 = __toESM(require("path"), 1);
+var import_types56 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
   graph.forEachNode((id, attrs) => {
-    if (attrs.type !== import_types53.NodeType.FileNode) return;
+    if (attrs.type !== import_types56.NodeType.FileNode) return;
     if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
       orphans.push(id);
     }
@@ -14915,14 +15382,14 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
   const bases = [scanPath, ...serviceDirs];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== import_types53.Provenance.EXTRACTED) return;
+    if (edge.provenance !== import_types56.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (import_node_path63.default.isAbsolute(evidenceFile)) {
-      if (!(0, import_node_fs30.existsSync)(evidenceFile)) toDrop.push(id);
+    if (import_node_path66.default.isAbsolute(evidenceFile)) {
+      if (!(0, import_node_fs33.existsSync)(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => (0, import_node_fs30.existsSync)(import_node_path63.default.join(base, evidenceFile)));
+    const found = bases.some((base) => (0, import_node_fs33.existsSync)(import_node_path66.default.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -14979,7 +15446,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   }
   const droppedEntries = drainDroppedExtracted();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = import_node_path64.default.join(import_node_path64.default.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = import_node_path67.default.join(import_node_path67.default.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -15013,7 +15480,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 
 // src/diff.ts
 init_cjs_shims();
-var import_node_fs31 = require("fs");
+var import_node_fs34 = require("fs");
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -15022,7 +15489,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await import_node_fs31.promises.readFile(target, "utf8");
+  const raw = await import_node_fs34.promises.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -15090,9 +15557,9 @@ function canonicalJson(value) {
 
 // src/persist.ts
 init_cjs_shims();
-var import_node_fs32 = require("fs");
-var import_node_path65 = __toESM(require("path"), 1);
-var import_types54 = require("@neat.is/types");
+var import_node_fs35 = require("fs");
+var import_node_path68 = __toESM(require("path"), 1);
+var import_types57 = require("@neat.is/types");
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -15116,7 +15583,7 @@ function migrateV5ToV6(payload) {
   if (Array.isArray(nodes)) {
     for (const node of nodes) {
       const attrs = node.attributes;
-      if (!attrs || attrs.type !== import_types54.NodeType.InfraNode) continue;
+      if (!attrs || attrs.type !== import_types57.NodeType.InfraNode) continue;
       if (attrs.kind !== "sql-table" && attrs.kind !== "supabase-table") continue;
       if (!Array.isArray(attrs.columns)) attrs.columns = [];
     }
@@ -15132,12 +15599,12 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = import_types54.Provenance.OBSERVED;
+      attrs.provenance = import_types57.Provenance.OBSERVED;
       const type = typeof attrs.type === "string" ? attrs.type : void 0;
       const source = typeof attrs.source === "string" ? attrs.source : void 0;
       const target = typeof attrs.target === "string" ? attrs.target : void 0;
       if (type && source && target) {
-        const newId = (0, import_types54.observedEdgeId)(source, target, type);
+        const newId = (0, import_types57.observedEdgeId)(source, target, type);
         attrs.id = newId;
         if (edge.key) edge.key = newId;
       }
@@ -15146,7 +15613,7 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await import_node_fs32.promises.mkdir(import_node_path65.default.dirname(filePath), { recursive: true });
+  await import_node_fs35.promises.mkdir(import_node_path68.default.dirname(filePath), { recursive: true });
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -15156,13 +15623,13 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await import_node_fs32.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await import_node_fs32.promises.rename(tmp, outPath);
+  await import_node_fs35.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
+  await import_node_fs35.promises.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await import_node_fs32.promises.readFile(outPath, "utf8");
+    raw = await import_node_fs35.promises.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -15236,23 +15703,23 @@ function startPersistLoop(graph, outPath, opts = {}) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_path66 = __toESM(require("path"), 1);
+var import_node_path69 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path66.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path66.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path66.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path66.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path66.default.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: import_node_path69.default.join(baseDir, "graph.json"),
+      errorsPath: import_node_path69.default.join(baseDir, "errors.ndjson"),
+      staleEventsPath: import_node_path69.default.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: import_node_path69.default.join(baseDir, "embeddings.json"),
+      policyViolationsPath: import_node_path69.default.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: import_node_path66.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path66.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path66.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path66.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path66.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: import_node_path69.default.join(baseDir, `${project}.json`),
+    errorsPath: import_node_path69.default.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: import_node_path69.default.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: import_node_path69.default.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: import_node_path69.default.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -15292,20 +15759,20 @@ function parseExtraProjects(raw) {
 
 // src/registry.ts
 init_cjs_shims();
-var import_node_fs33 = require("fs");
+var import_node_fs36 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path67 = __toESM(require("path"), 1);
-var import_types55 = require("@neat.is/types");
+var import_node_path70 = __toESM(require("path"), 1);
+var import_types58 = require("@neat.is/types");
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path67.default.resolve(override);
-  return import_node_path67.default.join(import_node_os3.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path70.default.resolve(override);
+  return import_node_path70.default.join(import_node_os3.default.homedir(), ".neat");
 }
 function registryPath() {
-  return import_node_path67.default.join(neatHome(), "projects.json");
+  return import_node_path70.default.join(neatHome(), "projects.json");
 }
 function daemonsDir() {
-  return import_node_path67.default.join(neatHome(), "daemons");
+  return import_node_path70.default.join(neatHome(), "daemons");
 }
 function isFiniteInt(v) {
   return typeof v === "number" && Number.isFinite(v);
@@ -15338,7 +15805,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const dir = daemonsDir();
   let names;
   try {
-    names = await import_node_fs33.promises.readdir(dir);
+    names = await import_node_fs36.promises.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -15346,10 +15813,10 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const file = import_node_path67.default.join(dir, name);
+    const file = import_node_path70.default.join(dir, name);
     let raw;
     try {
-      raw = await import_node_fs33.promises.readFile(file, "utf8");
+      raw = await import_node_fs36.promises.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -15377,7 +15844,7 @@ async function readRegistry() {
   const file = registryPath();
   let raw;
   try {
-    raw = await import_node_fs33.promises.readFile(file, "utf8");
+    raw = await import_node_fs36.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: 1, projects: [] };
@@ -15385,7 +15852,7 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types55.RegistryFileSchema.parse(parsed);
+  return import_types58.RegistryFileSchema.parse(parsed);
 }
 async function getProject(name) {
   const reg = await readRegistry();
@@ -15460,8 +15927,8 @@ init_auth();
 // src/connectors-config.ts
 init_cjs_shims();
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path68 = __toESM(require("path"), 1);
-var import_node_fs34 = require("fs");
+var import_node_path71 = __toESM(require("path"), 1);
+var import_node_fs37 = require("fs");
 var CONNECTORS_CONFIG_VERSION = 1;
 var EnvRefUnsetError = class extends Error {
   ref;
@@ -15475,17 +15942,17 @@ var EnvRefUnsetError = class extends Error {
 };
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path68.default.resolve(override);
-  return import_node_path68.default.join(import_node_os4.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path71.default.resolve(override);
+  return import_node_path71.default.join(import_node_os4.default.homedir(), ".neat");
 }
 function connectorsConfigPath(home = neatHome2()) {
-  return import_node_path68.default.join(home, "connectors.json");
+  return import_node_path71.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_fs34.promises.stat(file);
+    const stat = await import_node_fs37.promises.stat(file);
     if ((stat.mode & MODE_MASK_LOOSER_THAN_0600) !== 0) {
       const mode = (stat.mode & 511).toString(8).padStart(3, "0");
       console.warn(
@@ -15499,7 +15966,7 @@ async function readConnectorsConfig(home = neatHome2()) {
   const file = connectorsConfigPath(home);
   let raw;
   try {
-    raw = await import_node_fs34.promises.readFile(file, "utf8");
+    raw = await import_node_fs37.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: CONNECTORS_CONFIG_VERSION, connectors: [] };
@@ -15666,15 +16133,15 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 
 // src/connectors/index.ts
 init_cjs_shims();
-var import_types56 = require("@neat.is/types");
+var import_types59 = require("@neat.is/types");
 var NO_ENV = "unknown";
 function staticCallSiteFor(graph, serviceName, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
   const sites = [];
   for (const edgeId of graph.inboundEdges(targetNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.provenance !== import_types56.Provenance.EXTRACTED) continue;
-    const parsed = (0, import_types56.parseFileId)(edge.source);
+    if (edge.provenance !== import_types59.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types59.parseFileId)(edge.source);
     if (!parsed || parsed.service !== serviceName || !edge.evidence) continue;
     const site = { relPath: edge.evidence.file };
     if (edge.evidence.line !== void 0) site.line = edge.evidence.line;
@@ -15685,7 +16152,7 @@ function staticCallSiteFor(graph, serviceName, targetNodeId) {
 function routeCallSiteFor(graph, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
   const attrs = graph.getNodeAttributes(targetNodeId);
-  if (attrs.type !== import_types56.NodeType.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== import_types59.NodeType.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -16142,10 +16609,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(path71) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path71);
+function targetFromRestPath(path74) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path74);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path71);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path74);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -16256,23 +16723,23 @@ async function fetchPgStatStatements(connectionString, limit = DEFAULT_STATEMENT
 
 // src/connectors/supabase/resolve.ts
 init_cjs_shims();
-var import_types58 = require("@neat.is/types");
+var import_types61 = require("@neat.is/types");
 function createSupabaseResolveTarget(graph, config) {
   return (signal, _ctx) => {
     if (signal.targetKind !== SUPABASE_TABLE_TARGET_KIND && signal.targetKind !== SUPABASE_RPC_TARGET_KIND) {
       return null;
     }
-    const subResourceId = (0, import_types58.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
+    const subResourceId = (0, import_types61.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
     if (graph.hasNode(subResourceId)) {
-      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types58.EdgeType.CALLS };
+      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types61.EdgeType.CALLS };
     }
-    const bareResourceId = (0, import_types58.infraId)(signal.targetKind, signal.targetName);
+    const bareResourceId = (0, import_types61.infraId)(signal.targetKind, signal.targetName);
     if (graph.hasNode(bareResourceId)) {
-      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types58.EdgeType.CALLS };
+      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types61.EdgeType.CALLS };
     }
-    const projectLevelId = (0, import_types58.infraId)("supabase", config.nodeRef);
+    const projectLevelId = (0, import_types61.infraId)("supabase", config.nodeRef);
     if (graph.hasNode(projectLevelId)) {
-      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types58.EdgeType.CALLS };
+      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types61.EdgeType.CALLS };
     }
     return null;
   };
@@ -16365,7 +16832,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 
 // src/connectors/railway/index.ts
 init_cjs_shims();
-var import_types62 = require("@neat.is/types");
+var import_types65 = require("@neat.is/types");
 
 // src/connectors/railway/client.ts
 init_cjs_shims();
@@ -16516,7 +16983,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types62.NodeType.RouteNode) return;
+    if (node.type !== import_types65.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -16620,12 +17087,12 @@ function createRailwayResolveTarget(config) {
     const serviceName = config.serviceNameById[config.serviceId];
     if (!serviceName) return null;
     if (signal.targetKind === ROUTE_TARGET_KIND) {
-      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types62.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types65.EdgeType.CALLS };
     }
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: (0, import_types62.serviceId)(peerName), serviceName, edgeType: import_types62.EdgeType.CONNECTS_TO };
+      return { targetNodeId: (0, import_types65.serviceId)(peerName), serviceName, edgeType: import_types65.EdgeType.CONNECTS_TO };
     }
     return null;
   };
@@ -16749,9 +17216,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path71 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path71) return null;
-  return { resourceName, method, path: path71 };
+  const path74 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path74) return null;
+  return { resourceName, method, path: path74 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -16789,14 +17256,14 @@ function mapLogEntryToSignal(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path71 = pathFromRequestUrl(req.requestUrl);
-  if (path71 === null) return null;
+  const path74 = pathFromRequestUrl(req.requestUrl);
+  if (path74 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD2;
   return {
     targetKind: resourceType,
-    targetName: packFirebaseTargetName({ resourceName, method, path: path71 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path74 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -16813,7 +17280,7 @@ function mapLogEntriesToSignals(entries) {
 
 // src/connectors/firebase/resolve.ts
 init_cjs_shims();
-var import_types63 = require("@neat.is/types");
+var import_types66 = require("@neat.is/types");
 function neatServiceNameFor(resourceType, resourceName, serviceMap) {
   switch (resourceType) {
     case "cloud_function":
@@ -16828,7 +17295,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types63.NodeType.RouteNode) return;
+    if (node.type !== import_types66.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -16860,7 +17327,7 @@ function createFirebaseResolveTarget(graph, serviceMap) {
     return {
       targetNodeId: match.routeNodeId,
       serviceName,
-      edgeType: import_types63.EdgeType.CALLS
+      edgeType: import_types66.EdgeType.CALLS
     };
   };
 }
@@ -16887,7 +17354,7 @@ init_cjs_shims();
 
 // src/connectors/cloudflare/connector.ts
 init_cjs_shims();
-var import_types65 = require("@neat.is/types");
+var import_types68 = require("@neat.is/types");
 
 // src/connectors/cloudflare/client.ts
 init_cjs_shims();
@@ -17003,7 +17470,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 path71 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path74 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -17011,7 +17478,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path71 ? { path: path71 } : {},
+    ...path74 ? { path: path74 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -17051,19 +17518,19 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === import_types65.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === import_types68.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path71) {
-  const normalizedPath = normalizePathTemplate(path71);
+function findMatchingRouteNode(graph, serviceName, method, path74) {
+  const normalizedPath = normalizePathTemplate(path74);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types65.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types68.NodeType.RouteNode || a.service !== serviceName) return;
     if (!a.pathTemplate || normalizePathTemplate(a.pathTemplate) !== normalizedPath) return;
     const routeMethod = (a.method ?? "").toUpperCase();
     if (routeMethod !== "ALL" && routeMethod !== method) return;
@@ -17075,18 +17542,18 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path71 } = signal;
+    const { method, path: path74 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path71) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path71) ?? wholeFileId;
+      if (!method || !path74) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path74) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
-      const wholeFileId = (0, import_types65.fileId)(mapping.service, mapping.entryFile);
+      const wholeFileId = (0, import_types68.fileId)(mapping.service, mapping.entryFile);
       return {
         targetNodeId: resolveRouteGrain(mapping.service, wholeFileId),
         serviceName: mapping.service,
-        edgeType: import_types65.EdgeType.CALLS
+        edgeType: import_types68.EdgeType.CALLS
       };
     }
     const taggedFileId = findTaggedWorkerFileNode(graph, scriptName);
@@ -17095,13 +17562,13 @@ function createCloudflareResolveTarget(config, graph) {
       return {
         targetNodeId: resolveRouteGrain(fileNode.service, taggedFileId),
         serviceName: fileNode.service,
-        edgeType: import_types65.EdgeType.CALLS
+        edgeType: import_types68.EdgeType.CALLS
       };
     }
     return {
-      targetNodeId: (0, import_types65.infraId)("cloudflare-worker", scriptName),
+      targetNodeId: (0, import_types68.infraId)("cloudflare-worker", scriptName),
       serviceName: scriptName,
-      edgeType: import_types65.EdgeType.CALLS,
+      edgeType: import_types68.EdgeType.CALLS,
       ensureInfraNode: { kind: "cloudflare-worker", name: scriptName, provider: "cloudflare" }
     };
   };
@@ -17297,14 +17764,14 @@ function diffNeonStatementsToSignals(rows, previous, observedAtIso) {
 
 // src/connectors/neon/resolve.ts
 init_cjs_shims();
-var import_types69 = require("@neat.is/types");
+var import_types72 = require("@neat.is/types");
 function createNeonResolveTarget(config) {
   return (signal) => {
     if (signal.targetKind !== NEON_SQL_TABLE_TARGET_KIND || !signal.targetName) return null;
     return {
-      targetNodeId: (0, import_types69.infraId)("sql-table", signal.targetName),
+      targetNodeId: (0, import_types72.infraId)("sql-table", signal.targetName),
       serviceName: config.serviceName,
-      edgeType: import_types69.EdgeType.CALLS,
+      edgeType: import_types72.EdgeType.CALLS,
       ensureInfraNode: { kind: "sql-table", name: signal.targetName, provider: "neon" }
     };
   };
@@ -17430,9 +17897,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path71 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path71) return null;
-  return { serviceName, method, path: path71 };
+  const path74 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path74) return null;
+  return { serviceName, method, path: path74 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -17461,14 +17928,14 @@ function mapLogEntryToSignal2(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path71 = pathFromRequestUrl2(req.requestUrl);
-  if (path71 === null) return null;
+  const path74 = pathFromRequestUrl2(req.requestUrl);
+  if (path74 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD4;
   return {
     targetKind: CLOUD_RUN_TARGET_KIND,
-    targetName: packCloudRunTargetName({ serviceName, method, path: path71 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path74 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -17485,14 +17952,14 @@ function mapLogEntriesToSignals2(entries) {
 
 // src/connectors/cloud-run/resolve.ts
 init_cjs_shims();
-var import_types73 = require("@neat.is/types");
+var import_types76 = require("@neat.is/types");
 var CLOUD_RUN_SERVICE_INFRA_KIND = "cloud-run-service";
 function findMatchingRouteNode2(graph, serviceName, method, normalizedPath) {
   let found = null;
   graph.forEachNode((_id, attrs) => {
     if (found) return;
     const node = attrs;
-    if (node.type !== import_types73.NodeType.RouteNode) return;
+    if (node.type !== import_types76.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -17507,23 +17974,23 @@ 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: path71 } = identity;
+    const { serviceName: gcpServiceName, method, path: path74 } = identity;
     const mappedService = config.serviceMap?.[gcpServiceName];
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path71)
+        normalizePathTemplate(path74)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types73.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types76.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types73.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
+      targetNodeId: (0, import_types76.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
       serviceName: mappedService ?? gcpServiceName,
-      edgeType: import_types73.EdgeType.CALLS,
+      edgeType: import_types76.EdgeType.CALLS,
       ensureInfraNode: {
         kind: CLOUD_RUN_SERVICE_INFRA_KIND,
         name: gcpServiceName,
@@ -17564,7 +18031,7 @@ function createCloudRunConnector(graph, config = {}) {
 
 // src/connectors/render/index.ts
 init_cjs_shims();
-var import_types76 = require("@neat.is/types");
+var import_types79 = require("@neat.is/types");
 
 // src/connectors/render/types.ts
 init_cjs_shims();
@@ -17642,7 +18109,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types76.NodeType.RouteNode) return;
+    if (node.type !== import_types79.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -17727,7 +18194,7 @@ function mapRenderRequestLogsToSignals(entries, routeIndex) {
 function createRenderResolveTarget(config) {
   return (signal) => {
     if (signal.targetKind === ROUTE_TARGET_KIND2) {
-      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types76.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types79.EdgeType.CALLS };
     }
     return null;
   };
@@ -17865,21 +18332,21 @@ function mapInsightsToSignals(rows, observedAtIso) {
 
 // src/connectors/planetscale/resolve.ts
 init_cjs_shims();
-var import_types80 = require("@neat.is/types");
+var import_types83 = require("@neat.is/types");
 var PLANETSCALE_DATABASE_KIND = "planetscale-database";
 function createPlanetscaleResolveTarget(graph, config) {
   const databaseName = `${config.organization}/${config.database}`;
   return (signal, _ctx) => {
     if (signal.targetKind !== PLANETSCALE_SQL_TABLE_TARGET_KIND || !signal.targetName) return null;
-    const tableId = (0, import_types80.infraId)("sql-table", signal.targetName);
+    const tableId = (0, import_types83.infraId)("sql-table", signal.targetName);
     if (graph.hasNode(tableId)) {
-      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types80.EdgeType.CALLS };
+      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types83.EdgeType.CALLS };
     }
-    const providerId = (0, import_types80.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
+    const providerId = (0, import_types83.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
     return {
       targetNodeId: providerId,
       serviceName: config.serviceName,
-      edgeType: import_types80.EdgeType.CALLS,
+      edgeType: import_types83.EdgeType.CALLS,
       ensureInfraNode: { kind: PLANETSCALE_DATABASE_KIND, name: databaseName, provider: "planetscale" }
     };
   };
@@ -18144,7 +18611,7 @@ function mapBuildsToSignals(builds, serviceName) {
 
 // src/connectors/eas/resolve.ts
 init_cjs_shims();
-var import_types85 = require("@neat.is/types");
+var import_types88 = require("@neat.is/types");
 var NO_ENV2 = "unknown";
 var EAS_JSON_PHASES = /* @__PURE__ */ new Set(["READ_EAS_JSON"]);
 var APP_CONFIG_PHASES = /* @__PURE__ */ new Set([
@@ -18160,8 +18627,8 @@ function configBasenamesForPhase(phase) {
 function configNodeService(graph, configNodeId) {
   for (const edgeId of graph.inboundEdges(configNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types85.EdgeType.CONFIGURED_BY) continue;
-    const parsed = (0, import_types85.parseFileId)(edge.source);
+    if (edge.type !== import_types88.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types88.parseFileId)(edge.source);
     if (parsed) return parsed.service;
   }
   return null;
@@ -18172,7 +18639,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== import_types85.NodeType.ConfigNode) return;
+    if (node.type !== import_types88.NodeType.ConfigNode) return;
     if (typeof node.name !== "string" || !basenames.includes(node.name)) return;
     if (anyMatch === null) anyMatch = id;
     if (configNodeService(graph, id) === serviceName) scoped = id;
@@ -18189,13 +18656,13 @@ function createEasResolveTarget(graph) {
     if (basenames.length > 0) {
       const configNodeId = findConfigNode(graph, basenames, serviceName);
       if (configNodeId) {
-        return { targetNodeId: configNodeId, serviceName, edgeType: import_types85.EdgeType.CALLS };
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types88.EdgeType.CALLS };
       }
     }
     return {
       targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
       serviceName,
-      edgeType: import_types85.EdgeType.CALLS
+      edgeType: import_types88.EdgeType.CALLS
     };
   };
 }
@@ -18874,11 +19341,11 @@ function registerRoutes(scope, ctx) {
       const candidates = req.query.type.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       const parsed = [];
       for (const c of candidates) {
-        const r = import_types88.DivergenceTypeSchema.safeParse(c);
+        const r = import_types91.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types88.DivergenceTypeSchema.options
+            allowed: import_types91.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -19220,7 +19687,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types88.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types91.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -19259,7 +19726,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
-    const parsed = import_types88.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types91.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -19580,8 +20047,8 @@ init_otel_grpc();
 
 // src/search.ts
 init_cjs_shims();
-var import_node_fs35 = require("fs");
-var import_node_path69 = __toESM(require("path"), 1);
+var import_node_fs38 = require("fs");
+var import_node_path72 = __toESM(require("path"), 1);
 var import_node_crypto4 = require("crypto");
 var DEFAULT_LIMIT = 10;
 var NOMIC_DIM = 768;
@@ -19735,7 +20202,7 @@ async function pickEmbedder() {
 }
 async function readCache(cachePath) {
   try {
-    const raw = await import_node_fs35.promises.readFile(cachePath, "utf8");
+    const raw = await import_node_fs38.promises.readFile(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return null;
     return parsed;
@@ -19744,8 +20211,8 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  await import_node_fs35.promises.mkdir(import_node_path69.default.dirname(cachePath), { recursive: true });
-  await import_node_fs35.promises.writeFile(cachePath, JSON.stringify(cache));
+  await import_node_fs38.promises.mkdir(import_node_path72.default.dirname(cachePath), { recursive: true });
+  await import_node_fs38.promises.writeFile(cachePath, JSON.stringify(cache));
 }
 var VectorIndex = class {
   constructor(embedder, cachePath) {
@@ -19959,14 +20426,14 @@ async function bootProject(registry, name, scanPath, baseDir) {
 async function main() {
   const baseDirEnv = process.env.NEAT_OUT_DIR;
   const legacyOutPath = process.env.NEAT_OUT_PATH;
-  const baseDir = baseDirEnv ? import_node_path70.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path70.default.resolve(import_node_path70.default.dirname(legacyOutPath)) : import_node_path70.default.resolve("./neat-out");
-  const defaultScanPath = import_node_path70.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
+  const baseDir = baseDirEnv ? import_node_path73.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path73.default.resolve(import_node_path73.default.dirname(legacyOutPath)) : import_node_path73.default.resolve("./neat-out");
+  const defaultScanPath = import_node_path73.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
   const registry = new Projects();
   await bootProject(registry, DEFAULT_PROJECT, defaultScanPath, baseDir);
   for (const name of parseExtraProjects(process.env.NEAT_PROJECTS)) {
     const envKey = `NEAT_PROJECT_SCAN_PATH_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
     const projectScan = process.env[envKey];
-    await bootProject(registry, name, projectScan ? import_node_path70.default.resolve(projectScan) : void 0, baseDir);
+    await bootProject(registry, name, projectScan ? import_node_path73.default.resolve(projectScan) : void 0, baseDir);
   }
   const host = process.env.HOST ?? "0.0.0.0";
   const port = Number(process.env.PORT ?? 8080);