@neat.is/core 0.8.1-dev.20260817 → 0.8.2-dev.20260818

package/dist/server.cjs

@@ -59,8 +59,8 @@ function mountBearerAuth(app, opts) {
   ]);
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path68 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
-    if (exactUnauthPaths.has(path68) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path68)) {
+    const path71 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    if (exactUnauthPaths.has(path71) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path71)) {
       done();
       return;
     }
@@ -192,8 +192,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path47.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path47.default.resolve(here, "..", "proto");
+  const here = import_node_path50.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path50.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -261,13 +261,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path47, import_node_crypto2, grpc, protoLoader;
+var import_node_url, import_node_path50, 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_path47 = __toESM(require("path"), 1);
+    import_node_path50 = __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 path68 = q === -1 ? v : v.slice(0, q);
-      if (path68.length > 0) return path68;
+      const path71 = q === -1 ? v : v.slice(0, q);
+      if (path71.length > 0) return path71;
     }
   }
   return void 0;
@@ -476,10 +476,10 @@ function parseOtlpRequest(body) {
   return out;
 }
 function loadProtoRoot() {
-  const here = import_node_path48.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path48.default.resolve(here, "..", "proto");
+  const here = import_node_path51.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path51.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path48.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path51.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_path48, import_node_url2, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
+var import_node_path51, 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_path48 = __toESM(require("path"), 1);
+    import_node_path51 = __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_path67 = __toESM(require("path"), 1);
+var import_node_path70 = __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_types85 = require("@neat.is/types");
+var import_types88 = 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"]);
+var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php", ".cs", ".java"]);
 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([
@@ -2338,6 +2338,10 @@ function languageForPath(relPath) {
       return "ruby";
     case ".php":
       return "php";
+    case ".cs":
+      return "csharp";
+    case ".java":
+      return "java";
     case ".ts":
     case ".tsx":
       return "typescript";
@@ -2874,8 +2878,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path68) {
-  return path68.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path71) {
+  return path71.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -3547,9 +3551,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path68 = rubyLiteral(k);
-    if (path68 === null) continue;
-    return { path: path68, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path71 = rubyLiteral(k);
+    if (path71 === null) continue;
+    return { path: path71, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -4777,7 +4781,7 @@ function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line)
   }
   return sid;
 }
-function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
+function landObservedSymbol(graph, fileNodeId, service, relPath, callSite, mint = true) {
   const line = callSite.line;
   if (line === void 0) return fileNodeId;
   let sawSymbol = false;
@@ -4792,7 +4796,7 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
     }
   });
   if (candidates.length > 0) return pickContainingSymbol(candidates, callSite.fn);
-  if (sawSymbol && callSite.fn) {
+  if (mint && sawSymbol && callSite.fn) {
     return ensureObservedSymbolNode(graph, fileNodeId, service, relPath, callSite.fn, line);
   }
   return fileNodeId;
@@ -5198,6 +5202,20 @@ function incidentAffectedNode(span, graph, scanPath) {
   const callSite = callSiteFromSpan(span, serviceNode, scanPath);
   if (callSite) {
     const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
+    const canonicalService = serviceNode && typeof serviceNode.name === "string" ? serviceNode.name : span.service;
+    if (graph) {
+      const fusedFileId = (0, import_types7.fileId)(canonicalService, relPath);
+      if (graph.hasNode(fusedFileId)) {
+        return landObservedSymbol(
+          graph,
+          fusedFileId,
+          canonicalService,
+          relPath,
+          { ...callSite, relPath },
+          false
+        );
+      }
+    }
     return (0, import_types7.fileId)(span.service, relPath);
   }
   return sid;
@@ -5536,7 +5554,11 @@ async function handleSpan(ctx, span) {
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
-        affectedNode
+        // Attribute to where the failure originated — the symbol / file / service
+        // the throwing span named (incidentAffectedNode, ADR-191) — the same
+        // source-based attribution the durable receiver write uses, not the
+        // outbound edge target this span happened to mint.
+        affectedNode: incidentAffectedNode(span, ctx.graph, ctx.scanPath)
       };
       await appendErrorEvent(ctx, ev);
     }
@@ -5574,29 +5596,29 @@ function promoteFrontierNodes(graph, opts = {}) {
     toPromote.push({ frontierId: id, serviceId: target });
   });
   let promoted = 0;
-  for (const { frontierId: frontierId2, serviceId: serviceId9 } of toPromote) {
+  for (const { frontierId: frontierId2, serviceId: serviceId12 } 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, serviceId9);
+    rewireFrontierEdges(graph, frontierId2, serviceId12);
     graph.dropNode(frontierId2);
     promoted++;
   }
   return promoted;
 }
-function rewireFrontierEdges(graph, frontierId2, serviceId9) {
+function rewireFrontierEdges(graph, frontierId2, serviceId12) {
   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, serviceId9, edgeId);
+    rebuildEdge(graph, edge, edge.source, serviceId12, edgeId);
   }
   for (const edgeId of outbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, serviceId9, edge.target, edgeId);
+    rebuildEdge(graph, edge, serviceId12, edge.target, edgeId);
   }
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
@@ -5915,19 +5937,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, path68, edges) {
-    if (path68.length > best.path.length) {
-      best = { path: [...path68], edges: [...edges] };
+  function step(node, path71, edges) {
+    if (path71.length > best.path.length) {
+      best = { path: [...path71], edges: [...edges] };
     }
-    if (path68.length - 1 >= maxDepth) return;
+    if (path71.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);
-      path68.push(srcId);
+      path71.push(srcId);
       edges.push(edge);
-      step(srcId, path68, edges);
-      path68.pop();
+      step(srcId, path71, edges);
+      path71.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -5942,7 +5964,7 @@ function databaseRootCauseShape(graph, origin, walk9) {
   for (const id of walk9.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId9, svc } = owner;
+    const { id: serviceId12, svc } = owner;
     const deps = svc.dependencies ?? {};
     for (const pair of candidatePairs) {
       const declared = deps[pair.driver];
@@ -5955,7 +5977,7 @@ function databaseRootCauseShape(graph, origin, walk9) {
       );
       if (!result.compatible) {
         return {
-          rootCauseNode: serviceId9,
+          rootCauseNode: serviceId12,
           rootCauseReason: result.reason ?? "incompatible driver",
           ...result.minDriverVersion ? {
             fixRecommendation: `Upgrade ${svc.name} ${pair.driver} driver to >= ${result.minDriverVersion}`
@@ -5970,7 +5992,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
   for (const id of walk9.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId9, svc } = owner;
+    const { id: serviceId12, svc } = owner;
     const deps = svc.dependencies ?? {};
     const serviceNodeEngine = svc.nodeEngine;
     for (const constraint of nodeEngineConstraints()) {
@@ -5979,7 +6001,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
       const result = checkNodeEngineConstraint(constraint, declared, serviceNodeEngine);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId9,
+          rootCauseNode: serviceId12,
           rootCauseReason: result.reason,
           ...result.requiredNodeVersion ? {
             fixRecommendation: `Bump ${svc.name}'s engines.node to >= ${result.requiredNodeVersion}`
@@ -5994,7 +6016,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
       const result = checkPackageConflict(conflict, declared, requiredDeclared);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId9,
+          rootCauseNode: serviceId12,
           rootCauseReason: result.reason,
           fixRecommendation: `Upgrade ${svc.name}'s ${conflict.requires.name} to >= ${conflict.requires.minVersion}`
         };
@@ -6046,7 +6068,11 @@ function legacyRootCause(graph, errorNodeId, errorEvent, incidents) {
 }
 var INCIDENT_ROOT_CAUSE_CONFIDENCE = 0.6;
 function incidentMatchesNode(ev, nodeId) {
-  return ev.affectedNode === nodeId || ev.service === nodeId.replace(/^service:/, "");
+  if (ev.affectedNode === nodeId) return true;
+  if (ev.service === nodeId.replace(/^service:/, "")) return true;
+  const sym = (0, import_types8.parseSymbolId)(ev.affectedNode);
+  if (sym && (0, import_types8.fileId)(sym.service, sym.relPath) === nodeId) return true;
+  return false;
 }
 function localizeFromIncidents(nodeId, incidents, errorEvent) {
   const pool = incidents && incidents.length > 0 ? incidents : errorEvent ? [errorEvent] : [];
@@ -6064,8 +6090,8 @@ function localizeFromIncidents(nodeId, incidents, errorEvent) {
   const reasonParts = [`${latest.service}: ${latest.errorMessage}`];
   if (location) reasonParts.push(`surfaced at ${location}`);
   const rootCauseReason = `${reasonParts.join(" \u2014 ")}${tail}`;
-  const localizesToFile = latest.affectedNode !== nodeId && latest.affectedNode.startsWith("file:");
-  const fileNode = localizesToFile ? latest.affectedNode : void 0;
+  const localizesFiner = latest.affectedNode !== nodeId && (latest.affectedNode.startsWith("file:") || latest.affectedNode.startsWith("symbol:"));
+  const fileNode = localizesFiner ? latest.affectedNode : void 0;
   const fixRecommendation = location ? `Inspect ${location}${route ? ` handling ${route}` : ""}` : route ? `Inspect ${latest.service}'s handler for ${route}` : void 0;
   return {
     rootCauseNode: fileNode ?? nodeId,
@@ -6091,9 +6117,9 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
 function isFailingCallEdge(e) {
   return e.type === import_types8.EdgeType.CALLS && (e.signal?.errorCount ?? 0) > 0;
 }
-function callSourcesForService(graph, serviceId9) {
-  const ids = [serviceId9];
-  for (const edgeId of graph.outboundEdges(serviceId9)) {
+function callSourcesForService(graph, serviceId12) {
+  const ids = [serviceId12];
+  for (const edgeId of graph.outboundEdges(serviceId12)) {
     const e = graph.getEdgeAttributes(edgeId);
     if (e.type !== import_types8.EdgeType.CONTAINS) continue;
     const tgt = graph.getNodeAttributes(e.target);
@@ -6117,9 +6143,9 @@ function failingCallDominates(e, id, curEdge, curId) {
   }
   return id < curId;
 }
-function dominantFailingCall(graph, serviceId9, visited) {
+function dominantFailingCall(graph, serviceId12, visited) {
   let best = null;
-  for (const src of callSourcesForService(graph, serviceId9)) {
+  for (const src of callSourcesForService(graph, serviceId12)) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (!isFailingCallEdge(e)) continue;
@@ -6134,26 +6160,26 @@ function dominantFailingCall(graph, serviceId9, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path68 = [originServiceId];
+  const path71 = [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;
-    path68.push(hop.nextService);
+    path71.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path68, edges, culprit: current };
+  return { path: path71, 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 path68 = [...chain.path];
+  const path71 = [...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));
@@ -6161,14 +6187,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path68.push(loc.fileNode);
+      path71.push(loc.fileNode);
       edgeProvenances.push(import_types8.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return import_types8.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path68,
+      traversalPath: path71,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -6180,7 +6206,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: path68,
+    traversalPath: path71,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -6550,6 +6576,22 @@ function findLoadOrigin(graph, alertNodeId, incidents, now) {
   }
   return best ? { node: best.node, ctx: best.ctx } : null;
 }
+var LOAD_ORIGIN_CONFIDENCE_CEILING = 0.9;
+function loadOriginConfidence(originCtx, seedCtx) {
+  const cleanSplit = seedCtx.errorsFromCallers > 0 && seedCtx.errorsEmittedHere === 0;
+  const partialSplit = seedCtx.errorsFromCallers > seedCtx.errorsEmittedHere;
+  let evidence = 0;
+  evidence += cleanSplit ? 0.45 : partialSplit ? 0.2 : 0;
+  evidence += seedCtx.stale ? 0.2 : 0;
+  evidence += isSaturated(seedCtx) ? 0.15 : 0;
+  evidence += (volumeWeight(originCtx.outboundVolume) - 0.5) * 0.4;
+  const anchor = 0.45;
+  const confidence = anchor + Math.min(1, evidence) * (LOAD_ORIGIN_CONFIDENCE_CEILING - anchor);
+  return Math.max(0, Math.min(LOAD_ORIGIN_CONFIDENCE_CEILING, confidence));
+}
+function displayNameOf(nodeId) {
+  return nodeId.replace(/^[a-z]+:/, "");
+}
 function getRootCause(graph, errorNodeId, errorEvent, incidents, opts) {
   const legacy = legacyRootCause(graph, errorNodeId, errorEvent, incidents);
   if (!legacy) return null;
@@ -6564,20 +6606,20 @@ function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
   const candidates = [];
   if (seedCtx && isVictimSeed(seedCtx)) {
     const origin = findLoadOrigin(graph, errorNodeId, incidents, now);
+    const staleNote = seedCtx.stale ? "; it has gone STALE under load" : "";
+    const satNote = isSaturated(seedCtx) ? `; its inbound p95 ${Math.round(seedCtx.latencyP95Ms)}ms is saturated` : "";
     if (origin) {
-      const path68 = findPath(graph, errorNodeId, origin.node, "up", ROOT_CAUSE_MAX_DEPTH);
-      const originConfidence = confidenceFromMix(path68?.edges ?? [], now);
+      const originName = displayNameOf(origin.node);
+      const seedName = displayNameOf(seedNode);
       candidates.push({
         node: origin.node,
         classification: "primary-failure",
-        reason: `Highest-volume upstream source (${origin.ctx.outboundVolume} observed outbound calls) driving a saturated/stale subgraph; the alerting path decays downstream into a starved victim rather than a fault at the callee.`,
+        reason: `${originName} is the root cause: it overloads the failing subgraph, and the alerting node ${seedName} is a downstream symptom, not the fault \u2014 errors reach ${seedName} from its callers (${seedCtx.errorsFromCallers}), none originate there${staleNote}${satNote}. ${originName} is the upstream source driving that load (${origin.ctx.outboundVolume} observed outbound calls).`,
         context: origin.ctx,
-        confidence: Math.max(0.3, Math.min(0.8, originConfidence || 0.5)),
+        confidence: loadOriginConfidence(origin.ctx, seedCtx),
         provenance: import_types8.Provenance.OBSERVED
       });
     }
-    const staleNote = seedCtx.stale ? "; the node has gone STALE" : "";
-    const satNote = isSaturated(seedCtx) ? `; inbound p95 ${Math.round(seedCtx.latencyP95Ms)}ms is saturated` : "";
     candidates.push({
       node: seedNode,
       classification: "symptom-only",
@@ -6600,25 +6642,36 @@ function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
   let traversalPath = legacy.traversalPath;
   let edgeProvenances = legacy.edgeProvenances;
   if (top.node !== seedNode) {
-    const path68 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path68) {
-      traversalPath = path68.nodes;
-      edgeProvenances = path68.edges.map((e) => e.provenance);
+    const path71 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path71) {
+      traversalPath = path71.nodes;
+      edgeProvenances = path71.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? import_types8.Provenance.OBSERVED];
     }
   }
+  const fixRecommendation = fixRecommendationForTop(top, seedNode, legacy);
   return import_types8.RootCauseResultSchema.parse({
     rootCauseNode: top.node,
     rootCauseReason: top.reason,
     traversalPath,
     edgeProvenances,
     confidence: top.confidence,
-    ...legacy.fixRecommendation ? { fixRecommendation: legacy.fixRecommendation } : {},
+    ...fixRecommendation ? { fixRecommendation } : {},
     candidates
   });
 }
+function fixRecommendationForTop(top, seedNode, legacy) {
+  if (top.classification === "primary-failure" && top.node === seedNode) {
+    return legacy.fixRecommendation;
+  }
+  const name = top.node.replace(/^service:/, "");
+  if (top.classification === "primary-failure") {
+    return `Reduce or throttle the load from ${name} (or scale the saturated downstream capacity it drives) \u2014 the failure originates at this overloading source, not the starved callee.`;
+  }
+  return `${name} is a saturated/starved downstream victim; investigate its inbound load and upstream callers, not its own handler.`;
+}
 
 // src/divergences.ts
 function bucketKey(source, target, type) {
@@ -7004,11 +7057,11 @@ init_cjs_shims();
 
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs14 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs17 = require("fs");
+var import_node_path19 = __toESM(require("path"), 1);
 var import_ignore = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
-var import_types13 = require("@neat.is/types");
+var import_types16 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
@@ -7201,19 +7254,234 @@ async function discoverPhpService(scanPath, dir) {
   return { pkg, dir, node };
 }
 
-// src/extract/owners.ts
+// src/extract/csharp.ts
 init_cjs_shims();
 var import_node_fs13 = require("fs");
 var import_node_path15 = __toESM(require("path"), 1);
+var import_types13 = require("@neat.is/types");
+var CSHARP_PROJECT_EXTS = /* @__PURE__ */ new Set([".csproj", ".sln"]);
+async function projectFiles(dir) {
+  const entries = await import_node_fs13.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (CSHARP_PROJECT_EXTS.has(import_node_path15.default.extname(entry.name).toLowerCase())) out.push(entry.name);
+  }
+  return out.sort();
+}
+var NESTED_PROJECT_DIR = "src";
+async function resolveProjectDir(dir) {
+  if ((await projectFiles(dir)).length > 0) return dir;
+  const nested = import_node_path15.default.join(dir, NESTED_PROJECT_DIR);
+  if ((await projectFiles(nested)).length > 0) return nested;
+  return null;
+}
+async function hasCsharpProject(dir) {
+  return await resolveProjectDir(dir) !== null;
+}
+function parseCsproj(source) {
+  const dependencies = {};
+  const re = /<PackageReference\b([^>]*?)\/?>/g;
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const attrs = m[1] ?? "";
+    const include = attrs.match(/\bInclude\s*=\s*"([^"]+)"/)?.[1];
+    if (!include) continue;
+    const version = attrs.match(/\bVersion\s*=\s*"([^"]+)"/)?.[1];
+    dependencies[include] = version ?? "";
+  }
+  return { dependencies };
+}
+async function discoverCsharpService(scanPath, dir) {
+  const projectDir = await resolveProjectDir(dir);
+  if (projectDir === null) return null;
+  const projects = await projectFiles(projectDir);
+  const csproj = projects.find((p) => p.toLowerCase().endsWith(".csproj"));
+  const name = csproj ? import_node_path15.default.basename(csproj, import_node_path15.default.extname(csproj)) : import_node_path15.default.basename(dir);
+  let dependencies = {};
+  if (csproj) {
+    const raw = await import_node_fs13.promises.readFile(import_node_path15.default.join(projectDir, csproj), "utf8").catch(() => "");
+    dependencies = parseCsproj(raw).dependencies;
+  }
+  const pkg = { name, dependencies };
+  const node = {
+    id: (0, import_types13.serviceId)(name),
+    type: import_types13.NodeType.ServiceNode,
+    name,
+    language: "csharp",
+    dependencies,
+    // Anchor on the directory that holds the project and its `.cs` files, so file
+    // attribution reaches the source whether it sits at the root or under `src/`.
+    repoPath: import_node_path15.default.relative(scanPath, projectDir)
+  };
+  return { pkg, dir: projectDir, node };
+}
+
+// src/extract/java.ts
+init_cjs_shims();
+var import_node_fs14 = require("fs");
+var import_node_path16 = __toESM(require("path"), 1);
+var import_types14 = require("@neat.is/types");
+var JAVA_MANIFESTS = ["pom.xml", "build.gradle", "build.gradle.kts"];
+async function hasJavaManifest(dir) {
+  for (const manifest of JAVA_MANIFESTS) {
+    if (await exists2(import_node_path16.default.join(dir, manifest))) return true;
+  }
+  return false;
+}
+function parsePomXml(source) {
+  const dependencies = {};
+  const depBlock = /<dependency\b[^>]*>([\s\S]*?)<\/dependency>/g;
+  let d;
+  while ((d = depBlock.exec(source)) !== null) {
+    const body = d[1] ?? "";
+    const groupId = body.match(/<groupId>\s*([^<]+?)\s*<\/groupId>/)?.[1];
+    const artifactId = body.match(/<artifactId>\s*([^<]+?)\s*<\/artifactId>/)?.[1];
+    if (!groupId || !artifactId) continue;
+    const version = body.match(/<version>\s*([^<]+?)\s*<\/version>/)?.[1];
+    dependencies[`${groupId}:${artifactId}`] = version ?? "";
+  }
+  const withoutBlocks = source.replace(/<parent\b[^>]*>[\s\S]*?<\/parent>/g, "").replace(/<dependencyManagement\b[^>]*>[\s\S]*?<\/dependencyManagement>/g, "").replace(/<dependencies\b[^>]*>[\s\S]*?<\/dependencies>/g, "").replace(/<build\b[^>]*>[\s\S]*?<\/build>/g, "");
+  const name = withoutBlocks.match(/<artifactId>\s*([^<]+?)\s*<\/artifactId>/)?.[1];
+  return { name, dependencies };
+}
+var GRADLE_CONFIGS = "implementation|api|compileOnly|runtimeOnly|compileOnlyApi|testImplementation|testRuntimeOnly|testCompileOnly|annotationProcessor|developmentOnly|runtimeClasspath";
+function parseGradle(source) {
+  const dependencies = {};
+  const re = new RegExp(`\\b(?:${GRADLE_CONFIGS})\\s*\\(?\\s*(['"])([^'"]+)\\1`, "g");
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const coord = m[2] ?? "";
+    const parts = coord.split(":");
+    if (parts.length < 2 || !parts[0] || !parts[1]) continue;
+    const key = `${parts[0]}:${parts[1]}`;
+    dependencies[key] = parts.slice(2).join(":");
+  }
+  return { dependencies };
+}
+async function discoverJavaService(scanPath, dir) {
+  const pomPath = import_node_path16.default.join(dir, "pom.xml");
+  const gradlePath = import_node_path16.default.join(dir, "build.gradle");
+  const gradleKtsPath = import_node_path16.default.join(dir, "build.gradle.kts");
+  let manifest = null;
+  if (await exists2(pomPath)) {
+    manifest = parsePomXml(await import_node_fs14.promises.readFile(pomPath, "utf8").catch(() => ""));
+  } else if (await exists2(gradlePath)) {
+    manifest = parseGradle(await import_node_fs14.promises.readFile(gradlePath, "utf8").catch(() => ""));
+  } else if (await exists2(gradleKtsPath)) {
+    manifest = parseGradle(await import_node_fs14.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
+  }
+  if (!manifest) return null;
+  const name = manifest.name?.trim() || import_node_path16.default.basename(dir);
+  const dependencies = manifest.dependencies;
+  const pkg = { name, dependencies };
+  const node = {
+    id: (0, import_types14.serviceId)(name),
+    type: import_types14.NodeType.ServiceNode,
+    name,
+    language: "java",
+    dependencies,
+    repoPath: import_node_path16.default.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+
+// src/extract/dockerfile-service.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");
+function languageForSourceExt(ext) {
+  switch (ext) {
+    case ".py":
+      return "python";
+    case ".go":
+      return "go";
+    case ".rb":
+      return "ruby";
+    case ".php":
+      return "php";
+    case ".cs":
+      return "csharp";
+    case ".java":
+      return "java";
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    default:
+      return null;
+  }
+}
+var LANGUAGE_PRECEDENCE = ["typescript", "javascript", "python", "go", "ruby", "php", "csharp", "java"];
+async function inferServiceLanguage(dir) {
+  const entries = await import_node_fs15.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();
+    if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
+    const lang = languageForSourceExt(ext);
+    if (!lang) continue;
+    counts.set(lang, (counts.get(lang) ?? 0) + 1);
+  }
+  if (counts.size === 0) return null;
+  let best = null;
+  let bestCount = -1;
+  for (const lang of LANGUAGE_PRECEDENCE) {
+    const c = counts.get(lang) ?? 0;
+    if (c > bestCount) {
+      best = lang;
+      bestCount = c;
+    }
+  }
+  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
+  // rather than probing a fixed filename (ADR-196).
+  await hasCsharpProject(dir) || // Java keys on a Maven / Gradle build manifest (ADR-197).
+  await hasJavaManifest(dir);
+}
+async function hasDockerfileDeclaredService(dir) {
+  if (!await exists2(import_node_path17.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 hasLanguageManifest(dir)) return null;
+  const language = await inferServiceLanguage(dir);
+  if (!language) return null;
+  const name = import_node_path17.default.basename(dir);
+  const pkg = { name, dependencies: {} };
+  const node = {
+    id: (0, import_types15.serviceId)(name),
+    type: import_types15.NodeType.ServiceNode,
+    name,
+    language,
+    dependencies: {},
+    repoPath: import_node_path17.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_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path15.default.join(scanPath, "CODEOWNERS"),
-    import_node_path15.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path18.default.join(scanPath, "CODEOWNERS"),
+    import_node_path18.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists2(file)) {
-      const raw = await import_node_fs13.promises.readFile(file, "utf8");
+      const raw = await import_node_fs16.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -7231,7 +7499,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path15.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path18.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -7247,7 +7515,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path15.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path18.default.join(serviceDir, "package.json");
   if (!await exists2(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -7284,33 +7552,36 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists2(import_node_path16.default.join(dir, "pyproject.toml")) || await exists2(import_node_path16.default.join(dir, "requirements.txt")) || await exists2(import_node_path16.default.join(dir, "setup.py"));
+  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"));
 }
 async function hasGoManifest(dir) {
-  return exists2(import_node_path16.default.join(dir, "go.mod"));
+  return exists2(import_node_path19.default.join(dir, "go.mod"));
 }
 async function hasRubyManifest(dir) {
-  return exists2(import_node_path16.default.join(dir, "Gemfile"));
+  return exists2(import_node_path19.default.join(dir, "Gemfile"));
 }
 async function hasPhpManifest(dir) {
-  return exists2(import_node_path16.default.join(dir, "composer.json"));
+  return exists2(import_node_path19.default.join(dir, "composer.json"));
+}
+async function hasCsharpManifest(dir) {
+  return hasCsharpProject(dir);
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path16.default.join(scanPath, ".gitignore");
+  const gitignorePath = import_node_path19.default.join(scanPath, ".gitignore");
   if (!await exists2(gitignorePath)) return null;
-  const raw = await import_node_fs14.promises.readFile(gitignorePath, "utf8");
+  const raw = await import_node_fs17.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_fs14.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs17.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_path16.default.join(current, entry.name);
+      const child = import_node_path19.default.join(current, entry.name);
       if (options.ig) {
-        const rel = import_node_path16.default.relative(scanPath, child).split(import_node_path16.default.sep).join("/");
+        const rel = import_node_path19.default.relative(scanPath, child).split(import_node_path19.default.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -7326,8 +7597,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = import_node_path16.default.join(scanPath, pattern);
-      if (await exists2(import_node_path16.default.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = import_node_path19.default.join(scanPath, pattern);
+      if (await exists2(import_node_path19.default.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -7336,13 +7607,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = import_node_path16.default.join(scanPath, ...staticSegments);
+    const start = import_node_path19.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_path16.default.relative(scanPath, dir).split(import_node_path16.default.sep).join("/");
-      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists2(import_node_path16.default.join(dir, "package.json"))) {
+      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"))) {
         found.add(dir);
       }
     });
@@ -7365,31 +7636,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_fs14.promises.readdir(dir).catch(() => []);
+  const entries = await import_node_fs17.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_path16.default.join(dir, "package.json");
+  const pkgPath = import_node_path19.default.join(dir, "package.json");
   if (!await exists2(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", import_node_path16.default.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", import_node_path19.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_types13.serviceId)(pkg.name),
-    type: import_types13.NodeType.ServiceNode,
+    id: (0, import_types16.serviceId)(pkg.name),
+    type: import_types16.NodeType.ServiceNode,
     name: pkg.name,
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path16.default.relative(scanPath, dir),
+    repoPath: import_node_path19.default.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -7400,18 +7671,18 @@ async function discoverPyService(scanPath, dir) {
   if (!py) return null;
   const pkg = pythonToPackage(py);
   const node = {
-    id: (0, import_types13.serviceId)(py.name),
-    type: import_types13.NodeType.ServiceNode,
+    id: (0, import_types16.serviceId)(py.name),
+    type: import_types16.NodeType.ServiceNode,
     name: py.name,
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: import_node_path16.default.relative(scanPath, dir)
+    repoPath: import_node_path19.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path16.default.join(scanPath, "package.json");
+  const rootPkgPath = import_node_path19.default.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists2(rootPkgPath)) {
     try {
@@ -7419,7 +7690,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        import_node_path16.default.relative(scanPath, rootPkgPath),
+        import_node_path19.default.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -7431,7 +7702,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)) {
+    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath) || await hasRubyManifest(scanPath) || await hasPhpManifest(scanPath) || await hasCsharpManifest(scanPath) || await hasJavaManifest(scanPath)) {
       candidateDirs.push(scanPath);
     }
     const ig = await loadGitignore(scanPath);
@@ -7440,9 +7711,11 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists2(import_node_path16.default.join(dir, "package.json"))) {
+        if (await exists2(import_node_path19.default.join(dir, "package.json"))) {
           candidateDirs.push(dir);
-        } else if (await hasPythonManifest(dir) || await hasGoManifest(dir) || await hasRubyManifest(dir) || await hasPhpManifest(dir)) {
+        } else if (await hasPythonManifest(dir) || await hasGoManifest(dir) || await hasRubyManifest(dir) || await hasPhpManifest(dir) || await hasCsharpManifest(dir) || await hasJavaManifest(dir)) {
+          candidateDirs.push(dir);
+        } else if (await hasDockerfileDeclaredService(dir)) {
           candidateDirs.push(dir);
         }
       }
@@ -7450,14 +7723,17 @@ async function discoverServices(scanPath) {
   }
   candidateDirs.sort();
   const seen = /* @__PURE__ */ new Map();
+  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);
+    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);
     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_path16.default.relative(scanPath, existingDir) || ".";
-      const b = import_node_path16.default.relative(scanPath, dir) || ".";
+      const a = import_node_path19.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path19.default.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -7494,20 +7770,20 @@ function addServiceNodes(graph, services) {
 
 // src/extract/aliases.ts
 init_cjs_shims();
-var import_node_path17 = __toESM(require("path"), 1);
-var import_node_fs15 = require("fs");
+var import_node_path20 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
 var import_yaml2 = require("yaml");
-var import_types14 = require("@neat.is/types");
+var import_types17 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
   "Service",
   "Deployment",
   "StatefulSet",
   "DaemonSet"
 ]);
-function addAliases(graph, serviceId9, candidates) {
-  if (!graph.hasNode(serviceId9)) return;
-  const node = graph.getNodeAttributes(serviceId9);
-  if (node.type !== import_types14.NodeType.ServiceNode) return;
+function addAliases(graph, serviceId12, candidates) {
+  if (!graph.hasNode(serviceId12)) return;
+  const node = graph.getNodeAttributes(serviceId12);
+  if (node.type !== import_types17.NodeType.ServiceNode) return;
   const set = new Set(node.aliases ?? []);
   for (const c of candidates) {
     if (!c) continue;
@@ -7516,20 +7792,20 @@ function addAliases(graph, serviceId9, candidates) {
   }
   if (set.size === 0) return;
   const updated = { ...node, aliases: [...set].sort() };
-  graph.replaceNodeAttributes(serviceId9, updated);
+  graph.replaceNodeAttributes(serviceId12, 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_path17.default.basename(s.dir), s.node.id);
+    map.set(import_node_path20.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_path17.default.join(scanPath, name);
+    const abs = import_node_path20.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -7542,19 +7818,19 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      import_node_path17.default.relative(scanPath, composePath),
+      import_node_path20.default.relative(scanPath, composePath),
       err
     );
     return;
   }
   if (!compose?.services) return;
   for (const [composeName, svc] of Object.entries(compose.services)) {
-    const serviceId9 = serviceIndex.get(composeName);
-    if (!serviceId9) continue;
+    const serviceId12 = serviceIndex.get(composeName);
+    if (!serviceId12) 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, serviceId9, aliases);
+    addAliases(graph, serviceId12, aliases);
   }
 }
 var LABEL_KEYS = /* @__PURE__ */ new Set([
@@ -7585,11 +7861,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = import_node_path17.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path20.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs15.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs18.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -7601,15 +7877,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_fs15.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs18.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_path17.default.join(start, entry.name);
+      const child = import_node_path20.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_path17.default.extname(entry.name))) {
-      out.push(import_node_path17.default.join(start, entry.name));
+    } 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));
     }
   }
   return out;
@@ -7636,7 +7912,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_fs15.promises.readFile(file, "utf8");
+    const content = await import_node_fs18.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -7661,14 +7937,14 @@ async function addServiceAliases(graph, scanPath, services) {
 
 // src/extract/files.ts
 init_cjs_shims();
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path21 = __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);
     for (const filePath of filePaths) {
-      const relPath = toPosix(import_node_path18.default.relative(service.dir, filePath));
+      const relPath = toPosix(import_node_path21.default.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -7684,11 +7960,17 @@ async function addFiles(graph, services) {
 
 // src/extract/symbols.ts
 init_cjs_shims();
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path22 = __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);
-var import_types15 = require("@neat.is/types");
+var import_tree_sitter_python3 = __toESM(require("tree-sitter-python"), 1);
+var import_tree_sitter_go3 = __toESM(require("tree-sitter-go"), 1);
+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 PARSE_CHUNK3 = 16384;
 var GRAMMAR_BY_EXT = {
   ".ts": import_tree_sitter_typescript.default.typescript,
@@ -7698,6 +7980,15 @@ var GRAMMAR_BY_EXT = {
   ".mjs": import_tree_sitter_javascript3.default,
   ".cjs": import_tree_sitter_javascript3.default
 };
+var SYMBOL_GRAMMAR_BY_EXT = {
+  ...GRAMMAR_BY_EXT,
+  ".py": import_tree_sitter_python3.default,
+  ".go": import_tree_sitter_go3.default,
+  ".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
+};
 function parseSource3(parser, source) {
   return parser.parse(
     (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK3)
@@ -7758,14 +8049,375 @@ function collectSymbolDefs(root) {
         break;
       }
     }
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child) visit(child, classCtx);
-    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child, classCtx);
+    }
+  };
+  visit(root, void 0);
+  return out;
+}
+function collectPythonSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "function_definition": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          if (classCtx) {
+            const kind = name === "__init__" ? "constructor" : "method";
+            push(kind, `${classCtx}.${name}`, node);
+          } else {
+            push("function", name, node);
+          }
+        }
+        const body = node.childForFieldName("body");
+        if (body) {
+          for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child) visit(child, void 0);
+          }
+        }
+        return;
+      }
+      case "class_definition": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("class", name, node);
+        const body = node.childForFieldName("body");
+        if (body) {
+          for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child) visit(child, name ?? classCtx);
+          }
+        }
+        return;
+      }
+      case "decorated_definition": {
+        const def = node.childForFieldName("definition");
+        if (def) visit(def, classCtx);
+        return;
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child, classCtx);
+    }
+  };
+  visit(root, void 0);
+  return out;
+}
+function goReceiverType(node) {
+  const receiver = node.childForFieldName("receiver");
+  if (!receiver) return void 0;
+  for (let i = 0; i < receiver.namedChildCount; i++) {
+    const param = receiver.namedChild(i);
+    if (param?.type !== "parameter_declaration") continue;
+    let typeNode = param.childForFieldName("type");
+    if (typeNode?.type === "pointer_type") typeNode = typeNode.namedChild(0) ?? typeNode;
+    if (typeNode?.type === "generic_type") {
+      typeNode = typeNode.childForFieldName("type") ?? typeNode.namedChild(0) ?? typeNode;
+    }
+    if (typeNode?.type === "type_identifier") return typeNode.text;
+    return typeNode?.text;
+  }
+  return void 0;
+}
+function collectGoSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const visit = (node) => {
+    switch (node.type) {
+      case "function_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("function", name, node);
+        break;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          const recv = goReceiverType(node);
+          push("method", recv ? `${recv}.${name}` : name, node);
+        }
+        break;
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+function collectRubySymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const nameText = (node) => node.childForFieldName("name")?.text.replace(/::/g, ".");
+  const walkBody = (node, ctx) => {
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const child = body.namedChild(i);
+      if (child) visit(child, ctx);
+    }
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "method":
+      case "singleton_method": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          if (classCtx) {
+            const kind = node.type === "method" && name === "initialize" ? "constructor" : "method";
+            push(kind, `${classCtx}.${name}`, node);
+          } else {
+            push("function", name, node);
+          }
+        }
+        walkBody(node, void 0);
+        return;
+      }
+      case "class":
+      case "module": {
+        const name = nameText(node);
+        if (name) push("class", classCtx ? `${classCtx}.${name}` : name, node);
+        walkBody(node, name ? classCtx ? `${classCtx}.${name}` : name : classCtx);
+        return;
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child, classCtx);
+    }
+  };
+  visit(root, void 0);
+  return out;
+}
+function collectPhpSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const dot = (s) => s.replace(/\\/g, ".").replace(/::/g, ".").replace(/^\.+/, "");
+  const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+  const walkChildren = (container, nsCtx, classCtx) => {
+    let ns = nsCtx;
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (!child) continue;
+      if (child.type === "namespace_definition" && !child.childForFieldName("body")) {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) ns = dot(nameNode.text);
+        continue;
+      }
+      visit(child, ns, classCtx);
+    }
+  };
+  const walkBody = (node, nsCtx, classCtx) => {
+    const body = node.childForFieldName("body");
+    if (body) walkChildren(body, nsCtx, classCtx);
+  };
+  const visit = (node, nsCtx, classCtx) => {
+    switch (node.type) {
+      case "function_definition": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("function", join(nsCtx, name), node);
+        walkBody(node, nsCtx, void 0);
+        return;
+      }
+      case "class_declaration":
+      case "trait_declaration":
+      case "interface_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(nsCtx, name) : classCtx;
+        if (name) push("class", full, node);
+        walkBody(node, nsCtx, full);
+        return;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          const kind = name === "__construct" ? "constructor" : "method";
+          push(kind, join(classCtx ?? nsCtx, name), node);
+        }
+        return;
+      }
+      case "namespace_definition": {
+        const nameNode = node.childForFieldName("name");
+        const ns = nameNode ? dot(nameNode.text) : nsCtx;
+        walkBody(node, ns, classCtx);
+        return;
+      }
+    }
+    walkChildren(node, nsCtx, classCtx);
+  };
+  walkChildren(root, void 0, void 0);
+  return out;
+}
+function collectCsharpSymbolDefs(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 walkChildren = (container, nsCtx, classCtx) => {
+    let ns = nsCtx;
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (!child) continue;
+      if (child.type === "file_scoped_namespace_declaration") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) ns = join(nsCtx, nameNode.text);
+        continue;
+      }
+      visit(child, ns, classCtx);
+    }
+  };
+  const walkBody = (node, nsCtx, classCtx) => {
+    const body = node.childForFieldName("body");
+    if (body) walkChildren(body, nsCtx, classCtx);
+  };
+  const visit = (node, nsCtx, classCtx) => {
+    switch (node.type) {
+      case "namespace_declaration": {
+        const nameNode = node.childForFieldName("name");
+        const ns = nameNode ? join(nsCtx, nameNode.text) : nsCtx;
+        walkBody(node, ns, classCtx);
+        return;
+      }
+      case "class_declaration":
+      case "interface_declaration":
+      case "struct_declaration":
+      case "record_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(classCtx ?? nsCtx, name) : classCtx;
+        if (name) push("class", full, node);
+        walkBody(node, nsCtx, full);
+        return;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("method", join(classCtx ?? nsCtx, name), node);
+        return;
+      }
+      case "constructor_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("constructor", join(classCtx ?? nsCtx, name), node);
+        return;
+      }
+    }
+    walkChildren(node, nsCtx, classCtx);
+  };
+  walkChildren(root, void 0, void 0);
+  return out;
+}
+function collectJavaSymbolDefs(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;
+  let pkg;
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+    if (child?.type === "package_declaration") {
+      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 walkBody = (node, classCtx) => {
+    const body = node.childForFieldName("body");
+    if (body) walkChildren(body, classCtx);
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "class_declaration":
+      case "interface_declaration":
+      case "enum_declaration":
+      case "record_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(classCtx ?? pkg, name) : classCtx;
+        if (name) push("class", full, node);
+        walkBody(node, full);
+        return;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("method", join(classCtx ?? pkg, name), node);
+        return;
+      }
+      case "constructor_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("constructor", join(classCtx ?? pkg, name), node);
+        return;
+      }
+    }
+    walkChildren(node, classCtx);
   };
-  visit(root, void 0);
+  walkChildren(root, void 0);
   return out;
 }
+function collectSymbolDefsForExt(ext, root) {
+  switch (ext) {
+    case ".py":
+      return collectPythonSymbolDefs(root);
+    case ".go":
+      return collectGoSymbolDefs(root);
+    case ".rb":
+      return collectRubySymbolDefs(root);
+    case ".php":
+      return collectPhpSymbolDefs(root);
+    case ".cs":
+      return collectCsharpSymbolDefs(root);
+    case ".java":
+      return collectJavaSymbolDefs(root);
+    default:
+      return collectSymbolDefs(root);
+  }
+}
 function disambiguate(defs) {
   const counts = /* @__PURE__ */ new Map();
   for (const def of defs) counts.set(def.qualname, (counts.get(def.qualname) ?? 0) + 1);
@@ -7780,7 +8432,7 @@ function disambiguate(defs) {
 async function addSymbols(graph, services) {
   const parsers = /* @__PURE__ */ new Map();
   const parserForExt5 = (ext) => {
-    const grammar = GRAMMAR_BY_EXT[ext];
+    const grammar = SYMBOL_GRAMMAR_BY_EXT[ext];
     if (!grammar) return null;
     let parser = parsers.get(ext);
     if (!parser) {
@@ -7795,13 +8447,14 @@ async function addSymbols(graph, services) {
   for (const service of services) {
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
-      const parser = parserForExt5(import_node_path19.default.extname(file.path));
+      const ext = import_node_path22.default.extname(file.path);
+      const parser = parserForExt5(ext);
       if (!parser) continue;
-      const relPath = toPosix(import_node_path19.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path22.default.relative(service.dir, file.path));
       let defs;
       try {
         const tree = parseSource3(parser, file.content);
-        defs = collectSymbolDefs(tree.rootNode);
+        defs = collectSymbolDefsForExt(ext, tree.rootNode);
       } catch (err) {
         recordExtractionError("symbol extraction", file.path, err);
         continue;
@@ -7816,11 +8469,11 @@ async function addSymbols(graph, services) {
       nodesAdded += fn;
       edgesAdded += fe;
       for (const { def, disambiguator } of disambiguate(defs)) {
-        const sid = (0, import_types15.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
+        const sid = (0, import_types18.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
         if (!graph.hasNode(sid)) {
           const node = {
             id: sid,
-            type: import_types15.NodeType.SymbolNode,
+            type: import_types18.NodeType.SymbolNode,
             kind: def.kind,
             qualname: def.qualname,
             span: { startLine: def.startLine, endLine: def.endLine },
@@ -7831,15 +8484,15 @@ async function addSymbols(graph, services) {
           graph.addNode(sid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types15.extractedEdgeId)(fileNodeId, sid, import_types15.EdgeType.CONTAINS);
+        const containsId = (0, import_types18.extractedEdgeId)(fileNodeId, sid, import_types18.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: fileNodeId,
             target: sid,
-            type: import_types15.EdgeType.CONTAINS,
-            provenance: import_types15.Provenance.EXTRACTED,
-            confidence: (0, import_types15.confidenceForExtracted)("structural"),
+            type: import_types18.EdgeType.CONTAINS,
+            provenance: import_types18.Provenance.EXTRACTED,
+            confidence: (0, import_types18.confidenceForExtracted)("structural"),
             evidence: {
               file: relPath,
               line: def.startLine,
@@ -7857,9 +8510,9 @@ async function addSymbols(graph, services) {
 
 // src/extract/symbol-edges.ts
 init_cjs_shims();
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
-var import_types16 = require("@neat.is/types");
+var import_types19 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
   for (let i = 0; i < classHeritage.namedChildCount; i++) {
     const child = classHeritage.namedChild(i);
@@ -7964,10 +8617,10 @@ async function addSymbolEdges(graph, services) {
     const tsPaths = await loadTsPathConfig(service.dir);
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
-      const parser = parserForExt5(import_node_path20.default.extname(file.path));
+      const parser = parserForExt5(import_node_path23.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path20.default.relative(service.dir, file.path));
-      const fileDir = import_node_path20.default.dirname(file.path);
+      const relPath = toPosix(import_node_path23.default.relative(service.dir, file.path));
+      const fileDir = import_node_path23.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -7977,7 +8630,7 @@ async function addSymbolEdges(graph, services) {
       }
       const disambiguated = disambiguate(collectSymbolDefs(root));
       const locals = disambiguated.map(({ def, disambiguator }) => ({
-        sid: (0, import_types16.symbolId)(serviceName, relPath, def.qualname, disambiguator),
+        sid: (0, import_types19.symbolId)(serviceName, relPath, def.qualname, disambiguator),
         qualname: def.qualname,
         kind: def.kind,
         startLine: def.startLine,
@@ -8006,10 +8659,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_types16.symbolId)(serviceName, imp.targetRelPath, imp.importedName);
+          const candidate = (0, import_types19.symbolId)(serviceName, imp.targetRelPath, imp.importedName);
           if (graph.hasNode(candidate)) {
             const node = graph.getNodeAttributes(candidate);
-            if (node.type === import_types16.NodeType.SymbolNode && node.kind === wantKind) return candidate;
+            if (node.type === import_types19.NodeType.SymbolNode && node.kind === wantKind) return candidate;
           }
         }
         return null;
@@ -8036,7 +8689,7 @@ async function addSymbolEdges(graph, services) {
                   sourceSid: self.sid,
                   targetName: ext.name,
                   wantKind: "class",
-                  edgeType: import_types16.EdgeType.INHERITS,
+                  edgeType: import_types19.EdgeType.INHERITS,
                   line: ext.line
                 });
               }
@@ -8045,7 +8698,7 @@ async function addSymbolEdges(graph, services) {
                   sourceSid: self.sid,
                   targetName: impl.name,
                   wantKind: "class",
-                  edgeType: import_types16.EdgeType.IMPLEMENTS,
+                  edgeType: import_types19.EdgeType.IMPLEMENTS,
                   line: impl.line
                 });
               }
@@ -8061,7 +8714,7 @@ async function addSymbolEdges(graph, services) {
                 sourceSid: caller.sid,
                 targetName: fn.text,
                 wantKind: "function",
-                edgeType: import_types16.EdgeType.CALLS,
+                edgeType: import_types19.EdgeType.CALLS,
                 line
               });
             }
@@ -8077,15 +8730,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_types16.extractedEdgeId)(req.sourceSid, targetSid, req.edgeType);
+        const edgeId = (0, import_types19.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_types16.Provenance.EXTRACTED,
-          confidence: (0, import_types16.confidenceForExtracted)("structural"),
+          provenance: import_types19.Provenance.EXTRACTED,
+          confidence: (0, import_types19.confidenceForExtracted)("structural"),
           evidence: {
             file: relPath,
             line: req.line,
@@ -8102,9 +8755,9 @@ async function addSymbolEdges(graph, services) {
 
 // src/extract/actions.ts
 init_cjs_shims();
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 var import_tree_sitter5 = __toESM(require("tree-sitter"), 1);
-var import_types17 = require("@neat.is/types");
+var import_types20 = require("@neat.is/types");
 function stringLiteralText2(node) {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
@@ -8249,9 +8902,9 @@ async function addServerActions(graph, services) {
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(import_node_path21.default.extname(file.path));
+      const parser = parserForExt5(import_node_path24.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path21.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path24.default.relative(service.dir, file.path));
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8274,11 +8927,11 @@ async function addServerActions(graph, services) {
       nodesAdded += fn;
       edgesAdded += fe;
       for (const action of actions) {
-        const aid = (0, import_types17.serverActionId)(service.pkg.name, relPath, action.exportName);
+        const aid = (0, import_types20.serverActionId)(service.pkg.name, relPath, action.exportName);
         if (!graph.hasNode(aid)) {
           const node = {
             id: aid,
-            type: import_types17.NodeType.ServerActionNode,
+            type: import_types20.NodeType.ServerActionNode,
             name: action.exportName,
             service: service.pkg.name,
             module: relPath,
@@ -8290,15 +8943,15 @@ async function addServerActions(graph, services) {
           graph.addNode(aid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types17.extractedEdgeId)(fileNodeId, aid, import_types17.EdgeType.CONTAINS);
+        const containsId = (0, import_types20.extractedEdgeId)(fileNodeId, aid, import_types20.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: fileNodeId,
             target: aid,
-            type: import_types17.EdgeType.CONTAINS,
-            provenance: import_types17.Provenance.EXTRACTED,
-            confidence: (0, import_types17.confidenceForExtracted)("structural"),
+            type: import_types20.EdgeType.CONTAINS,
+            provenance: import_types20.Provenance.EXTRACTED,
+            confidence: (0, import_types20.confidenceForExtracted)("structural"),
             evidence: {
               file: relPath,
               line: action.line,
@@ -8312,10 +8965,10 @@ async function addServerActions(graph, services) {
     }
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(import_node_path21.default.extname(file.path));
+      const parser = parserForExt5(import_node_path24.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path21.default.relative(service.dir, file.path));
-      const fileDir = import_node_path21.default.dirname(file.path);
+      const relPath = toPosix(import_node_path24.default.relative(service.dir, file.path));
+      const fileDir = import_node_path24.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8328,7 +8981,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_types17.serverActionId)(service.pkg.name, target, binding.importedName);
+        const aid = (0, import_types20.serverActionId)(service.pkg.name, target, binding.importedName);
         if (graph.hasNode(aid)) actionBindings.set(local, aid);
       }
       if (actionBindings.size === 0) continue;
@@ -8343,15 +8996,15 @@ async function addServerActions(graph, services) {
           nodesAdded += ensured.nodesAdded;
           edgesAdded += ensured.edgesAdded;
         }
-        const callsId = (0, import_types17.extractedEdgeId)(clientFileId, aid, import_types17.EdgeType.CALLS);
+        const callsId = (0, import_types20.extractedEdgeId)(clientFileId, aid, import_types20.EdgeType.CALLS);
         if (graph.hasEdge(callsId)) continue;
         const edge = {
           id: callsId,
           source: clientFileId,
           target: aid,
-          type: import_types17.EdgeType.CALLS,
-          provenance: import_types17.Provenance.EXTRACTED,
-          confidence: (0, import_types17.confidenceForExtracted)("structural"),
+          type: import_types20.EdgeType.CALLS,
+          provenance: import_types20.Provenance.EXTRACTED,
+          confidence: (0, import_types20.confidenceForExtracted)("structural"),
           evidence: {
             file: relPath,
             line,
@@ -8368,14 +9021,14 @@ async function addServerActions(graph, services) {
 
 // src/extract/databases/index.ts
 init_cjs_shims();
-var import_node_path29 = __toESM(require("path"), 1);
-var import_types18 = require("@neat.is/types");
+var import_node_path32 = __toESM(require("path"), 1);
+var import_types21 = require("@neat.is/types");
 
 // src/extract/databases/db-config-yaml.ts
 init_cjs_shims();
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 async function parse(serviceDir) {
-  const yamlPath = import_node_path22.default.join(serviceDir, "db-config.yaml");
+  const yamlPath = import_node_path25.default.join(serviceDir, "db-config.yaml");
   if (!await exists2(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -8393,13 +9046,13 @@ var dbConfigYamlParser = { name: "db-config.yaml", parse };
 
 // src/extract/databases/dotenv.ts
 init_cjs_shims();
-var import_node_fs17 = require("fs");
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
+var import_node_path27 = __toESM(require("path"), 1);
 
 // src/extract/databases/shared.ts
 init_cjs_shims();
-var import_node_fs16 = require("fs");
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_fs19 = require("fs");
+var import_node_path26 = __toESM(require("path"), 1);
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -8438,18 +9091,18 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await import_node_fs16.promises.readFile(filePath, "utf8");
+    return await import_node_fs19.promises.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function resolveEnvVar(serviceDir, name) {
-  const entries = await import_node_fs16.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs19.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_path23.default.join(serviceDir, fileName));
+    const content = await readIfExists(import_node_path26.default.join(serviceDir, fileName));
     if (!content) continue;
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -8468,7 +9121,7 @@ async function resolveEnvVar(serviceDir, name) {
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = import_node_path23.default.join(serviceDir, rel);
+    const abs = import_node_path26.default.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -8526,15 +9179,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await import_node_fs17.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs20.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_path24.default.join(serviceDir, entry.name);
-    const content = await import_node_fs17.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path27.default.join(serviceDir, entry.name);
+    const content = await import_node_fs20.promises.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -8553,9 +9206,9 @@ var dotenvParser = { name: ".env", parse: parse2 };
 
 // src/extract/databases/prisma.ts
 init_cjs_shims();
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 async function parse3(serviceDir) {
-  const schemaPath = import_node_path25.default.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = import_node_path28.default.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -8713,10 +9366,10 @@ var knexParser = { name: "knex", parse: parse5 };
 
 // src/extract/databases/ormconfig.ts
 init_cjs_shims();
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = import_node_path26.default.join(serviceDir, candidate);
+    const abs = import_node_path29.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];
@@ -8776,9 +9429,9 @@ var typeormParser = { name: "typeorm", parse: parse7 };
 
 // src/extract/databases/sequelize.ts
 init_cjs_shims();
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 async function parse8(serviceDir) {
-  const configPath = import_node_path27.default.join(serviceDir, "config", "config.json");
+  const configPath = import_node_path30.default.join(serviceDir, "config", "config.json");
   if (!await exists2(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -8805,7 +9458,7 @@ var sequelizeParser = { name: "sequelize", parse: parse8 };
 
 // src/extract/databases/docker-compose.ts
 init_cjs_shims();
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 function portFromService(svc) {
   for (const raw of svc.ports ?? []) {
     const str = String(raw);
@@ -8832,7 +9485,7 @@ function databaseFromEnv(svc) {
 }
 async function parse9(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path28.default.join(serviceDir, name);
+    const abs = import_node_path31.default.join(serviceDir, name);
     if (!await exists2(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -8873,8 +9526,8 @@ function compatibleDriversFor(engine) {
 }
 function toDatabaseNode(config) {
   return {
-    id: (0, import_types18.databaseId)(config.host),
-    type: import_types18.NodeType.DatabaseNode,
+    id: (0, import_types21.databaseId)(config.host),
+    type: import_types21.NodeType.DatabaseNode,
     name: config.database || config.host,
     engine: config.engine,
     engineVersion: config.engineVersion,
@@ -9004,7 +9657,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix(import_node_path29.default.relative(service.dir, config.sourceFile));
+      const relConfigFile = toPosix(import_node_path32.default.relative(service.dir, config.sourceFile));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -9013,14 +9666,14 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix(import_node_path29.default.relative(scanPath, config.sourceFile));
+      const evidenceFile = toPosix(import_node_path32.default.relative(scanPath, config.sourceFile));
       const edge = {
-        id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types18.EdgeType.CONNECTS_TO),
+        id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types21.EdgeType.CONNECTS_TO),
         source: fileNodeId,
         target: dbNode.id,
-        type: import_types18.EdgeType.CONNECTS_TO,
-        provenance: import_types18.Provenance.EXTRACTED,
-        confidence: (0, import_types18.confidenceForExtracted)("structural"),
+        type: import_types21.EdgeType.CONNECTS_TO,
+        provenance: import_types21.Provenance.EXTRACTED,
+        confidence: (0, import_types21.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       if (!graph.hasEdge(edge.id)) {
@@ -9031,26 +9684,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_path29.default.relative(scanPath, primary.sourceFile);
-      const cfgId = (0, import_types18.configId)(relPath);
+      const relPath = import_node_path32.default.relative(scanPath, primary.sourceFile);
+      const cfgId = (0, import_types21.configId)(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
-          type: import_types18.NodeType.ConfigNode,
-          name: import_node_path29.default.basename(primary.sourceFile),
+          type: import_types21.NodeType.ConfigNode,
+          name: import_node_path32.default.basename(primary.sourceFile),
           path: relPath,
-          fileType: isConfigFile(import_node_path29.default.basename(primary.sourceFile)).fileType || "config"
+          fileType: isConfigFile(import_node_path32.default.basename(primary.sourceFile)).fileType || "config"
         };
         graph.addNode(cfgId, cfgNode);
         nodesAdded++;
       }
       const cfgEdge = {
-        id: (0, import_types3.extractedEdgeId)(service.node.id, cfgId, import_types18.EdgeType.CONFIGURED_BY),
+        id: (0, import_types3.extractedEdgeId)(service.node.id, cfgId, import_types21.EdgeType.CONFIGURED_BY),
         source: service.node.id,
         target: cfgId,
-        type: import_types18.EdgeType.CONFIGURED_BY,
-        provenance: import_types18.Provenance.EXTRACTED,
-        confidence: (0, import_types18.confidenceForExtracted)("structural"),
+        type: import_types21.EdgeType.CONFIGURED_BY,
+        provenance: import_types21.Provenance.EXTRACTED,
+        confidence: (0, import_types21.confidenceForExtracted)("structural"),
         evidence: { file: toPosix(relPath) }
       };
       if (!graph.hasEdge(cfgEdge.id)) {
@@ -9080,15 +9733,15 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 
 // src/extract/configs.ts
 init_cjs_shims();
-var import_node_fs18 = require("fs");
-var import_node_path30 = __toESM(require("path"), 1);
-var import_types19 = require("@neat.is/types");
+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) {
   const out = [];
   async function walk9(current) {
-    const entries = await import_node_fs18.promises.readdir(current, { withFileTypes: true });
+    const entries = await import_node_fs21.promises.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = import_node_path30.default.join(current, entry.name);
+      const full = import_node_path33.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         if (await isPythonVenvDir(full)) continue;
@@ -9107,19 +9760,19 @@ async function addConfigNodes(graph, services, scanPath) {
   for (const service of services) {
     const configFiles = await walkConfigFiles(service.dir);
     for (const file of configFiles) {
-      const relPath = import_node_path30.default.relative(scanPath, file);
+      const relPath = import_node_path33.default.relative(scanPath, file);
       const node = {
-        id: (0, import_types19.configId)(relPath),
-        type: import_types19.NodeType.ConfigNode,
-        name: import_node_path30.default.basename(file),
+        id: (0, import_types22.configId)(relPath),
+        type: import_types22.NodeType.ConfigNode,
+        name: import_node_path33.default.basename(file),
         path: relPath,
-        fileType: isConfigFile(import_node_path30.default.basename(file)).fileType
+        fileType: isConfigFile(import_node_path33.default.basename(file)).fileType
       };
       if (!graph.hasNode(node.id)) {
         graph.addNode(node.id, node);
         nodesAdded++;
       }
-      const relToService = toPosix(import_node_path30.default.relative(service.dir, file));
+      const relToService = toPosix(import_node_path33.default.relative(service.dir, file));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -9129,13 +9782,13 @@ async function addConfigNodes(graph, services, scanPath) {
       nodesAdded += fn;
       edgesAdded += fe;
       const edge = {
-        id: (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types19.EdgeType.CONFIGURED_BY),
+        id: (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types22.EdgeType.CONFIGURED_BY),
         source: fileNodeId,
         target: node.id,
-        type: import_types19.EdgeType.CONFIGURED_BY,
-        provenance: import_types19.Provenance.EXTRACTED,
-        confidence: (0, import_types19.confidenceForExtracted)("structural"),
-        evidence: { file: relPath.split(import_node_path30.default.sep).join("/") }
+        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("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -9148,9 +9801,9 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/proto.ts
 init_cjs_shims();
-var import_node_fs19 = require("fs");
-var import_node_path31 = __toESM(require("path"), 1);
-var import_types20 = require("@neat.is/types");
+var import_node_fs22 = require("fs");
+var import_node_path34 = __toESM(require("path"), 1);
+var import_types23 = 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);
@@ -9189,14 +9842,14 @@ function grpcMethodsFromProto(content, fqPackage) {
 async function walkProtoFiles(dir) {
   const out = [];
   async function walk9(current) {
-    const entries = await import_node_fs19.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs22.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = import_node_path31.default.join(current, entry.name);
+      const full = import_node_path34.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk9(full);
-      } else if (entry.isFile() && import_node_path31.default.extname(entry.name) === PROTO_EXTENSION) {
+      } else if (entry.isFile() && import_node_path34.default.extname(entry.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -9211,10 +9864,10 @@ async function addGrpcMethods(graph, services) {
     const protoPaths = await walkProtoFiles(service.dir);
     for (const protoPath of protoPaths) {
       if (isTestPath(protoPath)) continue;
-      const relFile = toPosix(import_node_path31.default.relative(service.dir, protoPath));
+      const relFile = toPosix(import_node_path34.default.relative(service.dir, protoPath));
       let content;
       try {
-        content = await import_node_fs19.promises.readFile(protoPath, "utf8");
+        content = await import_node_fs22.promises.readFile(protoPath, "utf8");
       } catch (err) {
         recordExtractionError("proto extraction", protoPath, err);
         continue;
@@ -9228,11 +9881,11 @@ async function addGrpcMethods(graph, services) {
       }
       if (methods.length === 0) continue;
       for (const method of methods) {
-        const mid = (0, import_types20.grpcMethodId)(method.rpcService, method.rpcMethod);
+        const mid = (0, import_types23.grpcMethodId)(method.rpcService, method.rpcMethod);
         if (!graph.hasNode(mid)) {
           const node = {
             id: mid,
-            type: import_types20.NodeType.GrpcMethodNode,
+            type: import_types23.NodeType.GrpcMethodNode,
             name: `${method.rpcService}/${method.rpcMethod}`,
             rpcService: method.rpcService,
             rpcMethod: method.rpcMethod,
@@ -9243,15 +9896,15 @@ async function addGrpcMethods(graph, services) {
           graph.addNode(mid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types20.extractedEdgeId)(service.node.id, mid, import_types20.EdgeType.CONTAINS);
+        const containsId = (0, import_types23.extractedEdgeId)(service.node.id, mid, import_types23.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: service.node.id,
             target: mid,
-            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: relFile,
               line: method.line,
@@ -9269,16 +9922,16 @@ async function addGrpcMethods(graph, services) {
 
 // src/extract/calls/index.ts
 init_cjs_shims();
-var import_types38 = require("@neat.is/types");
+var import_types41 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path35 = __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_python3 = __toESM(require("tree-sitter-python"), 1);
-var import_types21 = require("@neat.is/types");
+var import_tree_sitter_python4 = __toESM(require("tree-sitter-python"), 1);
+var import_types24 = 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) {
@@ -9334,7 +9987,7 @@ var GRAMMAR_BY_EXT2 = {
   ".jsx": import_tree_sitter_javascript4.default,
   ".mjs": import_tree_sitter_javascript4.default,
   ".cjs": import_tree_sitter_javascript4.default,
-  ".py": import_tree_sitter_python3.default
+  ".py": import_tree_sitter_python4.default
 };
 function parserForExt(ext, cache) {
   const grammar = GRAMMAR_BY_EXT2[ext] ?? import_tree_sitter_javascript4.default;
@@ -9356,7 +10009,7 @@ async function addHttpCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt(import_node_path32.default.extname(file.path), parserCache);
+      const parser = parserForExt(import_node_path35.default.extname(file.path), parserCache);
       let sites;
       try {
         sites = callsFromSource(file.content, parser, knownHosts);
@@ -9365,14 +10018,14 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path32.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path35.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_types21.confidenceForExtracted)("url-literal-service-target");
+        const confidence = (0, import_types24.confidenceForExtracted)("url-literal-service-target");
         const ev = {
           file: relFile,
           line: site.line,
@@ -9386,25 +10039,25 @@ async function addHttpCallEdges(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        if (!(0, import_types21.passesExtractedFloor)(confidence)) {
+        if (!(0, import_types24.passesExtractedFloor)(confidence)) {
           noteExtractedDropped({
             source: fileNodeId,
             target: targetId,
-            type: import_types21.EdgeType.CALLS,
+            type: import_types24.EdgeType.CALLS,
             confidence,
             confidenceKind: "url-literal-service-target",
             evidence: ev
           });
           continue;
         }
-        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, targetId, import_types21.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, targetId, import_types24.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: targetId,
-            type: import_types21.EdgeType.CALLS,
-            provenance: import_types21.Provenance.EXTRACTED,
+            type: import_types24.EdgeType.CALLS,
+            provenance: import_types24.Provenance.EXTRACTED,
             confidence,
             evidence: ev
           };
@@ -9419,10 +10072,10 @@ async function addHttpCallEdges(graph, services) {
 
 // src/extract/calls/route-match.ts
 init_cjs_shims();
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path36 = __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_types22 = require("@neat.is/types");
+var import_types25 = require("@neat.is/types");
 var PARSE_CHUNK5 = 16384;
 function parseSource5(parser, source) {
   return parser.parse(
@@ -9587,9 +10240,9 @@ function buildRouteIndex(graph) {
   const index = /* @__PURE__ */ new Map();
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types22.NodeType.RouteNode) return;
+    if (node.type !== import_types25.NodeType.RouteNode) return;
     const route = attrs;
-    const owner = (0, import_types22.serviceId)(route.service);
+    const owner = (0, import_types25.serviceId)(route.service);
     const entry = {
       method: route.method.toUpperCase(),
       normalizedPath: normalizePathTemplate(route.pathTemplate),
@@ -9618,7 +10271,7 @@ async function addRouteCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      if (!JS_CLIENT_EXTENSIONS.has(import_node_path33.default.extname(file.path))) continue;
+      if (!JS_CLIENT_EXTENSIONS.has(import_node_path36.default.extname(file.path))) continue;
       let sites;
       try {
         sites = clientCallSitesFromSource(file.content, jsParser, knownHosts);
@@ -9627,7 +10280,7 @@ async function addRouteCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path33.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path36.default.relative(service.dir, file.path));
       for (const site of sites) {
         const serverServiceId = hostToNodeId.get(site.host);
         if (!serverServiceId || serverServiceId === service.node.id) continue;
@@ -9647,7 +10300,7 @@ async function addRouteCallEdges(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        const confidence = (0, import_types22.confidenceForExtracted)("verified-call-site");
+        const confidence = (0, import_types25.confidenceForExtracted)("verified-call-site");
         const ev = {
           file: relFile,
           line: site.line,
@@ -9655,25 +10308,25 @@ async function addRouteCallEdges(graph, services) {
           method: site.method ?? match.method,
           pathTemplate: site.pathTemplate
         };
-        if (!(0, import_types22.passesExtractedFloor)(confidence)) {
+        if (!(0, import_types25.passesExtractedFloor)(confidence)) {
           noteExtractedDropped({
             source: fileNodeId,
             target: match.routeNodeId,
-            type: import_types22.EdgeType.CALLS,
+            type: import_types25.EdgeType.CALLS,
             confidence,
             confidenceKind: "verified-call-site",
             evidence: ev
           });
           continue;
         }
-        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, match.routeNodeId, import_types22.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, match.routeNodeId, import_types25.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: match.routeNodeId,
-            type: import_types22.EdgeType.CALLS,
-            provenance: import_types22.Provenance.EXTRACTED,
+            type: import_types25.EdgeType.CALLS,
+            provenance: import_types25.Provenance.EXTRACTED,
             confidence,
             evidence: ev
           };
@@ -9688,8 +10341,8 @@ async function addRouteCallEdges(graph, services) {
 
 // src/extract/calls/kafka.ts
 init_cjs_shims();
-var import_node_path34 = __toESM(require("path"), 1);
-var import_types23 = require("@neat.is/types");
+var import_node_path37 = __toESM(require("path"), 1);
+var import_types26 = 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) {
@@ -9710,7 +10363,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, topic);
     out.push({
-      infraId: (0, import_types23.infraId)("kafka-topic", topic),
+      infraId: (0, import_types26.infraId)("kafka-topic", topic),
       name: topic,
       kind: "kafka-topic",
       edgeType,
@@ -9719,7 +10372,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path34.default.relative(serviceDir, file.path),
+        file: import_node_path37.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -9732,8 +10385,8 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/redis.ts
 init_cjs_shims();
-var import_node_path35 = __toESM(require("path"), 1);
-var import_types24 = require("@neat.is/types");
+var import_node_path38 = __toESM(require("path"), 1);
+var import_types27 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
   const out = [];
@@ -9746,7 +10399,7 @@ function redisEndpointsFromFile(file, serviceDir) {
     seen.add(host);
     const line = lineOf(file.content, host);
     out.push({
-      infraId: (0, import_types24.infraId)("redis", host),
+      infraId: (0, import_types27.infraId)("redis", host),
       name: host,
       kind: "redis",
       edgeType: "CALLS",
@@ -9755,7 +10408,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: import_node_path35.default.relative(serviceDir, file.path),
+        file: import_node_path38.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -9766,8 +10419,8 @@ function redisEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/aws.ts
 init_cjs_shims();
-var import_node_path36 = __toESM(require("path"), 1);
-var import_types25 = require("@neat.is/types");
+var import_node_path39 = __toESM(require("path"), 1);
+var import_types28 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
 function hasMarker(text, markers) {
@@ -9791,7 +10444,7 @@ function awsEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, name);
     out.push({
-      infraId: (0, import_types25.infraId)(kind, name),
+      infraId: (0, import_types28.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -9800,7 +10453,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path36.default.relative(serviceDir, file.path),
+        file: import_node_path39.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -9825,8 +10478,8 @@ function awsEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/grpc.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 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['"`]/;
@@ -9875,7 +10528,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
     const { kind } = classified;
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types26.infraId)(kind, name),
+      infraId: (0, import_types29.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -9884,7 +10537,7 @@ function grpcEndpointsFromFile(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)
       }
@@ -9895,8 +10548,8 @@ function grpcEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/supabase.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 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;
@@ -9944,7 +10597,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
     seen.add(name);
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types27.infraId)("supabase", name),
+      infraId: (0, import_types30.infraId)("supabase", name),
       name,
       kind: "supabase",
       edgeType: "CALLS",
@@ -9954,7 +10607,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_path38.default.relative(serviceDir, file.path),
+        file: import_node_path41.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -9975,13 +10628,13 @@ function supabaseEndpointsFromFile(file, serviceDir) {
       seen.add(key);
       const line = lineOf(file.content, am[0]);
       out.push({
-        infraId: (0, import_types27.infraId)(kind, resource),
+        infraId: (0, import_types30.infraId)(kind, resource),
         name: resource,
         kind,
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         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)
         }
@@ -9993,10 +10646,10 @@ function supabaseEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/firestore.ts
 init_cjs_shims();
-var import_node_path39 = __toESM(require("path"), 1);
+var import_node_path42 = __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_types28 = require("@neat.is/types");
+var import_types31 = 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) {
@@ -10164,7 +10817,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_path39.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt2(import_node_path42.default.extname(file.path)), file.content);
   const clientVars = firestoreClientVars(tree.rootNode);
   const collLine = /* @__PURE__ */ new Map();
   const writes = /* @__PURE__ */ new Map();
@@ -10257,7 +10910,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
       }
     }
     out.push({
-      infraId: (0, import_types28.infraId)("firestore-collection", collPath),
+      infraId: (0, import_types31.infraId)("firestore-collection", collPath),
       name: collPath,
       kind: "firestore-collection",
       edgeType: "CALLS",
@@ -10268,7 +10921,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
       ...columnSet.size > 0 ? { columns: [...columnSet] } : {},
       ...sdkWrites ? { sdkWrites } : {},
       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)
       }
@@ -10279,8 +10932,8 @@ function firestoreEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/mongoose.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 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*\)/;
@@ -10425,12 +11078,12 @@ function collectModelDefs(content, pluralizeOn) {
 function endpoint(r, file, serviceDir, matchText) {
   const line = lineOf(file.content, matchText);
   return {
-    infraId: (0, import_types29.infraId)(r.kind, r.name),
+    infraId: (0, import_types32.infraId)(r.kind, r.name),
     name: r.name,
     kind: r.kind,
     edgeType: "CALLS",
     confidenceKind: "verified-call-site",
-    evidence: { file: import_node_path40.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+    evidence: { file: import_node_path43.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
   };
 }
 function mongooseEndpointsFromFile(file, serviceDir) {
@@ -10520,7 +11173,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_path40.default.relative(serviceDir, f.path)), fx);
+    if (fx) registry.set(toPosix(import_node_path43.default.relative(serviceDir, f.path)), fx);
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -10531,7 +11184,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_path40.default.dirname(f.path), serviceDir, null);
+      const resolvedRel = await resolveJsImport(b.specifier, import_node_path43.default.dirname(f.path), serviceDir, null);
       if (!resolvedRel) continue;
       const fx = registry.get(resolvedRel);
       if (!fx) continue;
@@ -10575,15 +11228,15 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/sqlalchemy.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 var import_tree_sitter9 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_python4 = __toESM(require("tree-sitter-python"), 1);
-var import_types30 = require("@neat.is/types");
+var import_tree_sitter_python5 = __toESM(require("tree-sitter-python"), 1);
+var import_types33 = require("@neat.is/types");
 var SQLALCHEMY_IMPORT_RE = /(?:from|import)\s+(?:flask_sqlalchemy|sqlalchemy)\b/;
 var PARSE_CHUNK6 = 16384;
 function makePyParser3() {
   const p = new import_tree_sitter9.default();
-  p.setLanguage(import_tree_sitter_python4.default);
+  p.setLanguage(import_tree_sitter_python5.default);
   return p;
 }
 function parseSource6(parser, source) {
@@ -10714,7 +11367,7 @@ function sqlalchemyForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         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)
         }
@@ -10732,14 +11385,14 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
     if (seen.has(name)) return;
     seen.add(name);
     out.push({
-      infraId: (0, import_types30.infraId)("sql-table", name),
+      infraId: (0, import_types33.infraId)("sql-table", name),
       name,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       ...columns && columns.length > 0 ? { columns } : {},
       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)
       }
@@ -10840,13 +11493,13 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
       if (seen.has(key)) continue;
       seen.add(key);
       out.push({
-        infraId: (0, import_types30.infraId)("sql-table", t),
+        infraId: (0, import_types33.infraId)("sql-table", t),
         name: t,
         kind: "sql-table",
         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)
         }
@@ -10858,15 +11511,15 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/django-orm.ts
 init_cjs_shims();
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_path45 = __toESM(require("path"), 1);
 var import_tree_sitter10 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_python5 = __toESM(require("tree-sitter-python"), 1);
-var import_types31 = require("@neat.is/types");
+var import_tree_sitter_python6 = __toESM(require("tree-sitter-python"), 1);
+var import_types34 = require("@neat.is/types");
 var DJANGO_IMPORT_RE = /(?:from|import)\s+django\b/;
 var PARSE_CHUNK7 = 16384;
 function makePyParser4() {
   const p = new import_tree_sitter10.default();
-  p.setLanguage(import_tree_sitter_python5.default);
+  p.setLanguage(import_tree_sitter_python6.default);
   return p;
 }
 function parseSource7(parser, source) {
@@ -10928,7 +11581,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
   const tree = parseSource7(makePyParser4(), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const defaultAppLabel = import_node_path42.default.basename(import_node_path42.default.dirname(file.path));
+  const defaultAppLabel = import_node_path45.default.basename(import_node_path45.default.dirname(file.path));
   walk4(tree.rootNode, (node) => {
     if (node.type !== "class_definition") return;
     if (!extendsDjangoModel(node)) return;
@@ -10941,12 +11594,12 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types31.infraId)("sql-table", table),
+      infraId: (0, import_types34.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: import_node_path42.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+      evidence: { file: import_node_path45.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
     });
   });
   return out;
@@ -10954,10 +11607,10 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/drizzle.ts
 init_cjs_shims();
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path46 = __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_types32 = require("@neat.is/types");
+var import_types35 = require("@neat.is/types");
 var DRIZZLE_IMPORT_RE = /drizzle-orm/;
 var TABLE_BUILDERS = /* @__PURE__ */ new Set(["pgTable", "mysqlTable", "sqliteTable"]);
 function parserForExt3(ext) {
@@ -11032,7 +11685,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path43.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path46.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk9 = (node) => {
@@ -11048,14 +11701,14 @@ function drizzleEndpointsFromFile(file, serviceDir) {
           const columns = columnsFromObject(obj);
           const line = node.startPosition.row + 1;
           out.push({
-            infraId: (0, import_types32.infraId)("sql-table", tableName),
+            infraId: (0, import_types35.infraId)("sql-table", tableName),
             name: tableName,
             kind: "sql-table",
             edgeType: "CALLS",
             confidenceKind: "structural",
             columns,
             evidence: {
-              file: import_node_path43.default.relative(serviceDir, file.path),
+              file: import_node_path46.default.relative(serviceDir, file.path),
               line,
               snippet: snippet(file.content, line)
             }
@@ -11121,7 +11774,7 @@ function referencesTargetVar(call) {
 }
 function drizzleForeignKeys(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path43.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path46.default.extname(file.path)), file.content);
   const { tables, varToTable } = collectDrizzleTables(tree.rootNode);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -11140,7 +11793,7 @@ function drizzleForeignKeys(file, serviceDir) {
               childTable: table.tableName,
               parentTable,
               evidence: {
-                file: import_node_path43.default.relative(serviceDir, file.path),
+                file: import_node_path46.default.relative(serviceDir, file.path),
                 line,
                 snippet: snippet(file.content, line)
               }
@@ -11157,8 +11810,8 @@ function drizzleForeignKeys(file, serviceDir) {
 
 // src/extract/calls/prisma.ts
 init_cjs_shims();
-var import_node_path44 = __toESM(require("path"), 1);
-var import_types33 = require("@neat.is/types");
+var import_node_path47 = __toESM(require("path"), 1);
+var import_types36 = require("@neat.is/types");
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
   "String",
@@ -11206,14 +11859,14 @@ function prismaColumnsFromSchema(file, serviceDir) {
     if (seenTable.has(b.tableName)) return;
     seenTable.add(b.tableName);
     out.push({
-      infraId: (0, import_types33.infraId)("sql-table", b.tableName),
+      infraId: (0, import_types36.infraId)("sql-table", b.tableName),
       name: b.tableName,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "structural",
       columns: b.columns,
       evidence: {
-        file: import_node_path44.default.relative(serviceDir, file.path),
+        file: import_node_path47.default.relative(serviceDir, file.path),
         line: b.startLine,
         snippet: snippet(content, b.startLine)
       }
@@ -11274,7 +11927,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
 }
 async function prismaColumnEndpoints(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path44.default.join("prisma", "schema.prisma"),
+    import_node_path47.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -11349,7 +12002,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
               childTable: current.table,
               parentTable,
               evidence: {
-                file: import_node_path44.default.relative(serviceDir, file.path),
+                file: import_node_path47.default.relative(serviceDir, file.path),
                 line: lineNo,
                 snippet: snippet(content, lineNo)
               }
@@ -11364,7 +12017,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
 }
 async function prismaForeignKeys(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path44.default.join("prisma", "schema.prisma"),
+    import_node_path47.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -11375,15 +12028,15 @@ async function prismaForeignKeys(serviceDir) {
 
 // src/extract/calls/activerecord.ts
 init_cjs_shims();
-var import_node_path45 = __toESM(require("path"), 1);
+var import_node_path48 = __toESM(require("path"), 1);
 var import_tree_sitter12 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_ruby2 = __toESM(require("tree-sitter-ruby"), 1);
-var import_types34 = require("@neat.is/types");
+var import_tree_sitter_ruby3 = __toESM(require("tree-sitter-ruby"), 1);
+var import_types37 = require("@neat.is/types");
 var AR_SCHEMA_RE = /ActiveRecord::Schema/;
 var PARSE_CHUNK8 = 16384;
 function makeRubyParser2() {
   const p = new import_tree_sitter12.default();
-  p.setLanguage(import_tree_sitter_ruby2.default);
+  p.setLanguage(import_tree_sitter_ruby3.default);
   return p;
 }
 function parseSource8(parser, source) {
@@ -11576,14 +12229,14 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
     if (!table || seen.has(table.name)) return;
     seen.add(table.name);
     out.push({
-      infraId: (0, import_types34.infraId)("sql-table", table.name),
+      infraId: (0, import_types37.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_path45.default.relative(serviceDir, file.path),
+        file: import_node_path48.default.relative(serviceDir, file.path),
         line: table.line,
         snippet: snippet(file.content, table.line)
       }
@@ -11605,7 +12258,7 @@ function railsSchemaForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: import_node_path45.default.relative(serviceDir, file.path),
+        file: import_node_path48.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11682,13 +12335,13 @@ function railsModelEndpointsFromFile(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),
+        file: import_node_path48.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11725,7 +12378,7 @@ function railsModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path45.default.relative(serviceDir, file.path),
+          file: import_node_path48.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -11737,15 +12390,15 @@ function railsModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/eloquent.ts
 init_cjs_shims();
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_path49 = __toESM(require("path"), 1);
 var import_tree_sitter13 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_php2 = __toESM(require("tree-sitter-php"), 1);
-var import_types35 = require("@neat.is/types");
+var import_tree_sitter_php3 = __toESM(require("tree-sitter-php"), 1);
+var import_types38 = require("@neat.is/types");
 var LARAVEL_SCHEMA_RE = /\bSchema::(create|createIfNotExists|table)\b/;
 var PARSE_CHUNK9 = 16384;
 function makePhpParser2() {
   const p = new import_tree_sitter13.default();
-  p.setLanguage(import_tree_sitter_php2.default.php_only);
+  p.setLanguage(import_tree_sitter_php3.default.php_only);
   return p;
 }
 function parseSource9(parser, source) {
@@ -11987,14 +12640,14 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       }
     }
     out.push({
-      infraId: (0, import_types35.infraId)("sql-table", bp.table),
+      infraId: (0, import_types38.infraId)("sql-table", bp.table),
       name: bp.table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: import_node_path46.default.relative(serviceDir, file.path),
+        file: import_node_path49.default.relative(serviceDir, file.path),
         line: bp.line,
         snippet: snippet(file.content, bp.line)
       }
@@ -12016,7 +12669,7 @@ function laravelMigrationForeignKeys(file, serviceDir) {
       childTable,
       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)
       }
@@ -12130,13 +12783,13 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types35.infraId)("sql-table", table),
+      infraId: (0, import_types38.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       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)
       }
@@ -12172,7 +12825,7 @@ function laravelModelForeignKeys(file, serviceDir) {
         childTable,
         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)
         }
@@ -12184,10 +12837,10 @@ function laravelModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/go.ts
 init_cjs_shims();
-var import_node_path49 = __toESM(require("path"), 1);
+var import_node_path52 = __toESM(require("path"), 1);
 var import_tree_sitter14 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_go3 = __toESM(require("tree-sitter-go"), 1);
-var import_types36 = require("@neat.is/types");
+var import_tree_sitter_go4 = __toESM(require("tree-sitter-go"), 1);
+var import_types39 = require("@neat.is/types");
 init_otel();
 var PARSE_CHUNK10 = 16384;
 var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
@@ -12216,7 +12869,7 @@ var DATABASE_SQL_IMPORT = "database/sql";
 var SQLX_IMPORT = "github.com/jmoiron/sqlx";
 function makeGoParser3() {
   const p = new import_tree_sitter14.default();
-  p.setLanguage(import_tree_sitter_go3.default);
+  p.setLanguage(import_tree_sitter_go4.default);
   return p;
 }
 function parseSource10(parser, source) {
@@ -12259,7 +12912,7 @@ function firstStringLiteralArg(argsNode) {
   return null;
 }
 function goSqlEndpointsFromFile(file, serviceDir) {
-  if (import_node_path49.default.extname(file.path) !== ".go") return [];
+  if (import_node_path52.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]));
@@ -12281,14 +12934,14 @@ function goSqlEndpointsFromFile(file, serviceDir) {
     const columns = columnsFromSqlStatement(sql);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types36.infraId)("sql-table", table),
+      infraId: (0, import_types39.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path49.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path52.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12299,15 +12952,15 @@ function goSqlEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/gorm.ts
 init_cjs_shims();
-var import_node_path50 = __toESM(require("path"), 1);
+var import_node_path53 = __toESM(require("path"), 1);
 var import_tree_sitter15 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_go4 = __toESM(require("tree-sitter-go"), 1);
-var import_types37 = require("@neat.is/types");
+var import_tree_sitter_go5 = __toESM(require("tree-sitter-go"), 1);
+var import_types40 = require("@neat.is/types");
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK11 = 16384;
 function makeGoParser4() {
   const p = new import_tree_sitter15.default();
-  p.setLanguage(import_tree_sitter_go4.default);
+  p.setLanguage(import_tree_sitter_go5.default);
   return p;
 }
 function parseSource11(parser, source) {
@@ -12732,7 +13385,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
   seen.delete(struct.name);
 }
 function gormEndpointsFromFile(file, serviceDir) {
-  if (import_node_path50.default.extname(file.path) !== ".go") return [];
+  if (import_node_path53.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);
@@ -12747,14 +13400,14 @@ function gormEndpointsFromFile(file, serviceDir) {
     const columns = [];
     collectColumns(struct, structs, /* @__PURE__ */ new Set(), "", columns, /* @__PURE__ */ new Set());
     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: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path50.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path53.default.relative(serviceDir, file.path)),
         line: struct.line,
         snippet: snippet(file.content, struct.line)
       }
@@ -12763,7 +13416,7 @@ function gormEndpointsFromFile(file, serviceDir) {
   return out;
 }
 function gormForeignKeys(file, serviceDir) {
-  if (import_node_path50.default.extname(file.path) !== ".go") return [];
+  if (import_node_path53.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);
@@ -12778,7 +13431,7 @@ function gormForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: toPosix(import_node_path50.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path53.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12817,11 +13470,11 @@ function gormForeignKeys(file, serviceDir) {
 function edgeTypeFromEndpoint(ep) {
   switch (ep.edgeType) {
     case "PUBLISHES_TO":
-      return import_types38.EdgeType.PUBLISHES_TO;
+      return import_types41.EdgeType.PUBLISHES_TO;
     case "CONSUMES_FROM":
-      return import_types38.EdgeType.CONSUMES_FROM;
+      return import_types41.EdgeType.CONSUMES_FROM;
     default:
-      return import_types38.EdgeType.CALLS;
+      return import_types41.EdgeType.CALLS;
   }
 }
 function isAwsKind(kind) {
@@ -12881,7 +13534,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: import_types38.NodeType.InfraNode,
+          type: import_types41.NodeType.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -12894,21 +13547,21 @@ async function addExternalEndpointEdges(graph, services) {
       }
       if (ep.columns && ep.columns.length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === import_types38.NodeType.InfraNode) {
+        if (node.type === import_types41.NodeType.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldColumns(
               node.columns,
               ep.columns,
-              import_types38.Provenance.EXTRACTED,
-              (0, import_types38.confidenceForExtracted)(ep.confidenceKind)
+              import_types41.Provenance.EXTRACTED,
+              (0, import_types41.confidenceForExtracted)(ep.confidenceKind)
             )
           });
         }
       }
       if (ep.sdkWrites && Object.keys(ep.sdkWrites).length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === import_types38.NodeType.InfraNode) {
+        if (node.type === import_types41.NodeType.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldSdkWrites(node.columns, ep.sdkWrites)
@@ -12916,7 +13569,7 @@ async function addExternalEndpointEdges(graph, services) {
         }
       }
       const edgeType = edgeTypeFromEndpoint(ep);
-      const confidence = (0, import_types38.confidenceForExtracted)(ep.confidenceKind);
+      const confidence = (0, import_types41.confidenceForExtracted)(ep.confidenceKind);
       const relFile = toPosix(ep.evidence.file);
       const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
@@ -12926,7 +13579,7 @@ async function addExternalEndpointEdges(graph, services) {
       );
       nodesAdded += n;
       edgesAdded += e;
-      if (!(0, import_types38.passesExtractedFloor)(confidence)) {
+      if (!(0, import_types41.passesExtractedFloor)(confidence)) {
         noteExtractedDropped({
           source: fileNodeId,
           target: ep.infraId,
@@ -12946,7 +13599,7 @@ async function addExternalEndpointEdges(graph, services) {
           source: fileNodeId,
           target: ep.infraId,
           type: edgeType,
-          provenance: import_types38.Provenance.EXTRACTED,
+          provenance: import_types41.Provenance.EXTRACTED,
           confidence,
           evidence: ep.evidence
         };
@@ -12969,7 +13622,7 @@ async function addCallEdges(graph, services) {
 
 // src/extract/table-edges.ts
 init_cjs_shims();
-var import_types39 = require("@neat.is/types");
+var import_types42 = require("@neat.is/types");
 async function addTableEdges(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
@@ -12997,20 +13650,20 @@ async function addTableEdges(graph, services) {
     }
     refs.push(...modelRefs);
     for (const ref of refs) {
-      const childId = (0, import_types39.infraId)("sql-table", ref.childTable);
-      const parentId = (0, import_types39.infraId)("sql-table", ref.parentTable);
+      const childId = (0, import_types42.infraId)("sql-table", ref.childTable);
+      const parentId = (0, import_types42.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_types39.extractedEdgeId)(childId, parentId, import_types39.EdgeType.REFERENCES);
+      const edgeId = (0, import_types42.extractedEdgeId)(childId, parentId, import_types42.EdgeType.REFERENCES);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: childId,
         target: parentId,
-        type: import_types39.EdgeType.REFERENCES,
-        provenance: import_types39.Provenance.EXTRACTED,
-        confidence: (0, import_types39.confidenceForExtracted)("structural"),
+        type: import_types42.EdgeType.REFERENCES,
+        provenance: import_types42.Provenance.EXTRACTED,
+        confidence: (0, import_types42.confidenceForExtracted)("structural"),
         evidence: ref.evidence
       };
       graph.addEdgeWithKey(edgeId, childId, parentId, edge);
@@ -13023,7 +13676,7 @@ function ensureTableNode(graph, id, name) {
   if (graph.hasNode(id)) return 0;
   const node = {
     id,
-    type: import_types39.NodeType.InfraNode,
+    type: import_types42.NodeType.InfraNode,
     name,
     provider: "self",
     kind: "sql-table"
@@ -13037,16 +13690,16 @@ init_cjs_shims();
 
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
-var import_node_path51 = __toESM(require("path"), 1);
-var import_types41 = require("@neat.is/types");
+var import_node_path54 = __toESM(require("path"), 1);
+var import_types44 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
 init_cjs_shims();
-var import_types40 = require("@neat.is/types");
+var import_types43 = require("@neat.is/types");
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
-    id: (0, import_types40.infraId)(kind, name),
-    type: import_types40.NodeType.InfraNode,
+    id: (0, import_types43.infraId)(kind, name),
+    type: import_types43.NodeType.InfraNode,
     name,
     provider,
     kind,
@@ -13090,8 +13743,8 @@ function emitPlatformResourceEdge(graph, anchorId, edgeType, kind, name, provide
       source: anchorId,
       target: node.id,
       type: edgeType,
-      provenance: import_types40.Provenance.EXTRACTED,
-      confidence: (0, import_types40.confidenceForExtracted)("structural"),
+      provenance: import_types43.Provenance.EXTRACTED,
+      confidence: (0, import_types43.confidenceForExtracted)("structural"),
       evidence: { file: evidenceFile, ...line !== void 0 ? { line } : {} }
     };
     graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13108,7 +13761,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || import_node_path51.default.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || import_node_path54.default.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -13117,7 +13770,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_path51.default.join(scanPath, name);
+    const abs = import_node_path54.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -13130,13 +13783,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      import_node_path51.default.relative(scanPath, composePath),
+      import_node_path54.default.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = import_node_path51.default.relative(scanPath, composePath).split(import_node_path51.default.sep).join("/");
+  const evidenceFile = import_node_path54.default.relative(scanPath, composePath).split(import_node_path54.default.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -13158,15 +13811,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_types41.EdgeType.DEPENDS_ON);
+      const edgeId = (0, import_types3.extractedEdgeId)(sourceId, targetId, import_types44.EdgeType.DEPENDS_ON);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: sourceId,
         target: targetId,
-        type: import_types41.EdgeType.DEPENDS_ON,
-        provenance: import_types41.Provenance.EXTRACTED,
-        confidence: (0, import_types41.confidenceForExtracted)("structural"),
+        type: import_types44.EdgeType.DEPENDS_ON,
+        provenance: import_types44.Provenance.EXTRACTED,
+        confidence: (0, import_types44.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13178,9 +13831,9 @@ async function addComposeInfra(graph, scanPath, services) {
 
 // src/extract/infra/dockerfile.ts
 init_cjs_shims();
-var import_node_path52 = __toESM(require("path"), 1);
-var import_node_fs20 = require("fs");
-var import_types42 = require("@neat.is/types");
+var import_node_path55 = __toESM(require("path"), 1);
+var import_node_fs23 = require("fs");
+var import_types45 = require("@neat.is/types");
 function readDockerfile(content) {
   let image = null;
   const ports = [];
@@ -13209,15 +13862,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = import_node_path52.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path55.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs20.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs23.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        import_node_path52.default.relative(scanPath, dockerfilePath),
+        import_node_path55.default.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -13229,8 +13882,8 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix(import_node_path52.default.relative(service.dir, dockerfilePath));
-    const evidenceFile = toPosix(import_node_path52.default.relative(scanPath, dockerfilePath));
+    const relDockerfile = toPosix(import_node_path55.default.relative(service.dir, dockerfilePath));
+    const evidenceFile = toPosix(import_node_path55.default.relative(scanPath, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -13239,15 +13892,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
     );
     nodesAdded += fn;
     edgesAdded += fe;
-    const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types42.EdgeType.RUNS_ON);
+    const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types45.EdgeType.RUNS_ON);
     if (!graph.hasEdge(edgeId)) {
       const edge = {
         id: edgeId,
         source: fileNodeId,
         target: node.id,
-        type: import_types42.EdgeType.RUNS_ON,
-        provenance: import_types42.Provenance.EXTRACTED,
-        confidence: (0, import_types42.confidenceForExtracted)("structural"),
+        type: import_types45.EdgeType.RUNS_ON,
+        provenance: import_types45.Provenance.EXTRACTED,
+        confidence: (0, import_types45.confidenceForExtracted)("structural"),
         evidence: {
           file: evidenceFile,
           ...facts.entrypoint ? { snippet: facts.entrypoint.slice(0, 120) } : {}
@@ -13262,15 +13915,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
         graph.addNode(portNode.id, portNode);
         nodesAdded++;
       }
-      const portEdgeId = (0, import_types3.extractedEdgeId)(fileNodeId, portNode.id, import_types42.EdgeType.CONNECTS_TO);
+      const portEdgeId = (0, import_types3.extractedEdgeId)(fileNodeId, portNode.id, import_types45.EdgeType.CONNECTS_TO);
       if (graph.hasEdge(portEdgeId)) continue;
       const portEdge = {
         id: portEdgeId,
         source: fileNodeId,
         target: portNode.id,
-        type: import_types42.EdgeType.CONNECTS_TO,
-        provenance: import_types42.Provenance.EXTRACTED,
-        confidence: (0, import_types42.confidenceForExtracted)("structural"),
+        type: import_types45.EdgeType.CONNECTS_TO,
+        provenance: import_types45.Provenance.EXTRACTED,
+        confidence: (0, import_types45.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile, snippet: `EXPOSE ${port}` }
       };
       graph.addEdgeWithKey(portEdgeId, portEdge.source, portEdge.target, portEdge);
@@ -13282,23 +13935,23 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 
 // src/extract/infra/terraform.ts
 init_cjs_shims();
-var import_node_fs21 = require("fs");
-var import_node_path53 = __toESM(require("path"), 1);
-var import_types43 = require("@neat.is/types");
+var import_node_fs24 = require("fs");
+var import_node_path56 = __toESM(require("path"), 1);
+var import_types46 = 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_fs21.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs24.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_path53.default.join(start, entry.name);
+      const child = import_node_path56.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_path53.default.join(start, entry.name));
+      out.push(import_node_path56.default.join(start, entry.name));
     }
   }
   return out;
@@ -13329,8 +13982,8 @@ async function addTerraformResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs21.promises.readFile(file, "utf8");
-    const evidenceFile = toPosix(import_node_path53.default.relative(scanPath, file));
+    const content = await import_node_fs24.promises.readFile(file, "utf8");
+    const evidenceFile = toPosix(import_node_path56.default.relative(scanPath, file));
     const resources = [];
     const byKey = /* @__PURE__ */ new Map();
     RESOURCE_RE.lastIndex = 0;
@@ -13365,16 +14018,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_types43.EdgeType.DEPENDS_ON);
+        const edgeId = (0, import_types3.extractedEdgeId)(resource.nodeId, target.nodeId, import_types46.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_types43.EdgeType.DEPENDS_ON,
-          provenance: import_types43.Provenance.EXTRACTED,
-          confidence: (0, import_types43.confidenceForExtracted)("structural"),
+          type: import_types46.EdgeType.DEPENDS_ON,
+          provenance: import_types46.Provenance.EXTRACTED,
+          confidence: (0, import_types46.confidenceForExtracted)("structural"),
           evidence: { file: evidenceFile, line, snippet: key }
         };
         graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13387,8 +14040,8 @@ async function addTerraformResources(graph, scanPath) {
 
 // src/extract/infra/k8s.ts
 init_cjs_shims();
-var import_node_fs22 = require("fs");
-var import_node_path54 = __toESM(require("path"), 1);
+var import_node_fs25 = require("fs");
+var import_node_path57 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var K8S_KIND_TO_INFRA_KIND = {
   Service: "k8s-service",
@@ -13402,15 +14055,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_fs22.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs25.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_path54.default.join(start, entry.name);
+      const child = import_node_path57.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_path54.default.extname(entry.name))) {
-      out.push(import_node_path54.default.join(start, entry.name));
+    } 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));
     }
   }
   return out;
@@ -13419,7 +14072,7 @@ async function addK8sResources(graph, scanPath) {
   let nodesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await import_node_fs22.promises.readFile(file, "utf8");
+    const content = await import_node_fs25.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml3.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -13443,16 +14096,16 @@ async function addK8sResources(graph, scanPath) {
 
 // src/extract/infra/cloudflare.ts
 init_cjs_shims();
-var import_node_fs23 = require("fs");
-var import_node_path55 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
+var import_node_path58 = __toESM(require("path"), 1);
 var import_smol_toml2 = require("smol-toml");
-var import_types44 = require("@neat.is/types");
+var import_types47 = 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_path55.default.join(dir, filename);
+    const abs = import_node_path58.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs23.promises.readFile(abs, "utf8");
+    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));
     return { config, relFile: filename, raw };
   }
@@ -13494,8 +14147,8 @@ function addResourceEdge(graph, anchorId, edgeType, kind, name, evidenceFile, li
       source: anchorId,
       target: node.id,
       type: edgeType,
-      provenance: import_types44.Provenance.EXTRACTED,
-      confidence: (0, import_types44.confidenceForExtracted)("structural"),
+      provenance: import_types47.Provenance.EXTRACTED,
+      confidence: (0, import_types47.confidenceForExtracted)("structural"),
       evidence: { file: evidenceFile, ...line !== void 0 ? { line } : {} }
     };
     graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13513,11 +14166,11 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     try {
       read = await readWranglerConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra cloudflare", import_node_path55.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra cloudflare", import_node_path58.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read || !read.config.name) continue;
-    const evidenceFile = toPosix(import_node_path55.default.relative(scanPath, import_node_path55.default.join(service.dir, read.relFile)));
+    const evidenceFile = toPosix(import_node_path58.default.relative(scanPath, import_node_path58.default.join(service.dir, read.relFile)));
     discovered.push({ service, config: read.config, relFile: read.relFile, raw: read.raw, evidenceFile });
   }
   for (const worker of discovered) {
@@ -13529,7 +14182,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     }
     let anchorId = service.node.id;
     if (config.main) {
-      const entryRelPath = toPosix(import_node_path55.default.normalize(config.main));
+      const entryRelPath = toPosix(import_node_path58.default.normalize(config.main));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -13556,15 +14209,15 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       nodesAdded++;
     }
     if (runtimeNode.id !== anchorId) {
-      const runsOnId = (0, import_types3.extractedEdgeId)(anchorId, runtimeNode.id, import_types44.EdgeType.RUNS_ON);
+      const runsOnId = (0, import_types3.extractedEdgeId)(anchorId, runtimeNode.id, import_types47.EdgeType.RUNS_ON);
       if (!graph.hasEdge(runsOnId)) {
         const edge = {
           id: runsOnId,
           source: anchorId,
           target: runtimeNode.id,
-          type: import_types44.EdgeType.RUNS_ON,
-          provenance: import_types44.Provenance.EXTRACTED,
-          confidence: (0, import_types44.confidenceForExtracted)("structural"),
+          type: import_types47.EdgeType.RUNS_ON,
+          provenance: import_types47.Provenance.EXTRACTED,
+          confidence: (0, import_types47.confidenceForExtracted)("structural"),
           evidence: {
             file: evidenceFile,
             ...config.compatibility_date ? { snippet: `compatibility_date = ${config.compatibility_date}`.slice(0, 120) } : {}
@@ -13578,7 +14231,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types44.EdgeType.CONNECTS_TO,
+        import_types47.EdgeType.CONNECTS_TO,
         "cloudflare-route",
         route,
         evidenceFile,
@@ -13602,7 +14255,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
         const result = addResourceEdge(
           graph,
           anchorId,
-          import_types44.EdgeType.DEPENDS_ON,
+          import_types47.EdgeType.DEPENDS_ON,
           group.kind,
           name,
           evidenceFile,
@@ -13616,7 +14269,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types44.EdgeType.DEPENDS_ON,
+        import_types47.EdgeType.DEPENDS_ON,
         "cloudflare-cron",
         cron,
         evidenceFile,
@@ -13629,7 +14282,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types44.EdgeType.DEPENDS_ON,
+        import_types47.EdgeType.DEPENDS_ON,
         "cloudflare-env-var",
         varName,
         evidenceFile,
@@ -13642,15 +14295,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_types44.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(anchorId, target.anchorId, import_types47.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: anchorId,
             target: target.anchorId,
-            type: import_types44.EdgeType.CALLS,
-            provenance: import_types44.Provenance.EXTRACTED,
-            confidence: (0, import_types44.confidenceForExtracted)("structural"),
+            type: import_types47.EdgeType.CALLS,
+            provenance: import_types47.Provenance.EXTRACTED,
+            confidence: (0, import_types47.confidenceForExtracted)("structural"),
             evidence: { file: evidenceFile, line: lineContaining2(raw, svc.service) }
           };
           graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -13661,7 +14314,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types44.EdgeType.DEPENDS_ON,
+        import_types47.EdgeType.DEPENDS_ON,
         "cloudflare-service-binding",
         svc.service,
         evidenceFile,
@@ -13676,24 +14329,24 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 
 // src/extract/infra/vercel.ts
 init_cjs_shims();
-var import_node_fs24 = require("fs");
-var import_node_path56 = __toESM(require("path"), 1);
-var import_types45 = require("@neat.is/types");
+var import_node_fs27 = require("fs");
+var import_node_path59 = __toESM(require("path"), 1);
+var import_types48 = 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_path56.default.join(dir, filename);
+    const abs = import_node_path59.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs24.promises.readFile(abs, "utf8");
+    const raw = await import_node_fs27.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_path56.default.join(dir, ".vercel", "project.json");
+  const abs = import_node_path59.default.join(dir, ".vercel", "project.json");
   if (!await exists2(abs)) return void 0;
-  const parsed = JSON.parse(await import_node_fs24.promises.readFile(abs, "utf8"));
+  const parsed = JSON.parse(await import_node_fs27.promises.readFile(abs, "utf8"));
   return typeof parsed.projectName === "string" ? parsed.projectName : void 0;
 }
 function routeSource(route) {
@@ -13709,7 +14362,7 @@ async function addVercelServices(graph, services, scanPath) {
       read = await readVercelConfig(service.dir);
       projectName = await readLinkedProjectName(service.dir);
     } catch (err) {
-      recordExtractionError("infra vercel", import_node_path56.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra vercel", import_node_path59.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read && !projectName) continue;
@@ -13725,7 +14378,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_path56.default.relative(scanPath, import_node_path56.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path59.default.relative(scanPath, import_node_path59.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -13741,12 +14394,12 @@ async function addVercelServices(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types45.EdgeType.RUNS_ON, "vercel", "vercel");
-    for (const cron of config.crons ?? []) add(import_types45.EdgeType.DEPENDS_ON, "vercel-cron", cron.path ?? cron.schedule);
-    for (const varName of Object.keys(config.env ?? {})) add(import_types45.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
-    for (const varName of Object.keys(config.build?.env ?? {})) add(import_types45.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
+    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);
     for (const route of [...config.rewrites ?? [], ...config.redirects ?? [], ...config.routes ?? []]) {
-      add(import_types45.EdgeType.CONNECTS_TO, "vercel-route", routeSource(route));
+      add(import_types48.EdgeType.CONNECTS_TO, "vercel-route", routeSource(route));
     }
   }
   return { nodesAdded, edgesAdded };
@@ -13754,16 +14407,16 @@ async function addVercelServices(graph, services, scanPath) {
 
 // src/extract/infra/railway.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_smol_toml3 = require("smol-toml");
-var import_types46 = require("@neat.is/types");
+var import_types49 = 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_path57.default.join(dir, filename);
+    const abs = import_node_path60.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs25.promises.readFile(abs, "utf8");
+    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));
     return { config, relFile: filename, raw };
   }
@@ -13777,7 +14430,7 @@ async function addRailwayServices(graph, services, scanPath) {
     try {
       read = await readRailwayConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra railway", import_node_path57.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra railway", import_node_path60.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -13787,7 +14440,7 @@ async function addRailwayServices(graph, services, scanPath) {
     }
     const anchorId = service.node.id;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(import_node_path57.default.relative(scanPath, import_node_path57.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path60.default.relative(scanPath, import_node_path60.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -13803,24 +14456,24 @@ async function addRailwayServices(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types46.EdgeType.RUNS_ON, "railway", "railway");
-    add(import_types46.EdgeType.CONNECTS_TO, "railway-route", config.deploy?.healthcheckPath);
-    add(import_types46.EdgeType.DEPENDS_ON, "railway-cron", config.deploy?.cronSchedule);
+    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);
   }
   return { nodesAdded, edgesAdded };
 }
 
 // src/extract/infra/supabase.ts
 init_cjs_shims();
-var import_node_fs26 = require("fs");
-var import_node_path58 = __toESM(require("path"), 1);
+var import_node_fs29 = require("fs");
+var import_node_path61 = __toESM(require("path"), 1);
 var import_smol_toml4 = require("smol-toml");
-var import_types47 = require("@neat.is/types");
+var import_types50 = require("@neat.is/types");
 async function readSupabaseConfig(dir) {
-  const relFile = import_node_path58.default.join("supabase", "config.toml");
-  const abs = import_node_path58.default.join(dir, relFile);
+  const relFile = import_node_path61.default.join("supabase", "config.toml");
+  const abs = import_node_path61.default.join(dir, relFile);
   if (!await exists2(abs)) return null;
-  const raw = await import_node_fs26.promises.readFile(abs, "utf8");
+  const raw = await import_node_fs29.promises.readFile(abs, "utf8");
   const config = (0, import_smol_toml4.parse)(raw);
   return { config, relFile, raw };
 }
@@ -13832,7 +14485,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
     try {
       read = await readSupabaseConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra supabase", import_node_path58.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra supabase", import_node_path61.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -13847,7 +14500,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
       });
     }
     const anchorId = service.node.id;
-    const evidenceFile = toPosix(import_node_path58.default.relative(scanPath, import_node_path58.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path61.default.relative(scanPath, import_node_path61.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -13863,10 +14516,10 @@ async function addSupabaseProjects(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types47.EdgeType.RUNS_ON, "supabase", "supabase");
-    for (const fn of Object.keys(config.functions ?? {})) add(import_types47.EdgeType.DEPENDS_ON, "supabase-function", fn);
-    if (config.storage) add(import_types47.EdgeType.DEPENDS_ON, "supabase-storage", "storage");
-    if (config.auth) add(import_types47.EdgeType.DEPENDS_ON, "supabase-auth", "auth");
+    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");
   }
   return { nodesAdded, edgesAdded };
 }
@@ -13889,10 +14542,10 @@ async function addInfra(graph, scanPath, services) {
 
 // src/extract/zod-shapes.ts
 init_cjs_shims();
-var import_node_path59 = __toESM(require("path"), 1);
+var import_node_path62 = __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_types48 = require("@neat.is/types");
+var import_types51 = require("@neat.is/types");
 var ZOD_IMPORT_RE = /\bzod\b/;
 var ZOD_OBJECTS = /* @__PURE__ */ new Set(["z", "zod"]);
 function parserForExt4(ext) {
@@ -13984,7 +14637,7 @@ function topLevelSchemas(root) {
 }
 function zodShapesFromFile(file, serviceDir) {
   if (!ZOD_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt4(import_node_path59.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt4(import_node_path62.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const { name, call } of topLevelSchemas(tree.rootNode)) {
@@ -13998,11 +14651,11 @@ function zodShapesFromFile(file, serviceDir) {
     seen.add(name);
     const line = call.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types48.infraId)("zod-schema", name),
+      infraId: (0, import_types51.infraId)("zod-schema", name),
       name,
       fields,
       evidence: {
-        file: import_node_path59.default.relative(serviceDir, file.path),
+        file: import_node_path62.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14033,7 +14686,7 @@ async function addZodShapes(graph, services) {
         if (!graph.hasNode(shape.infraId)) {
           const node = {
             id: shape.infraId,
-            type: import_types48.NodeType.InfraNode,
+            type: import_types51.NodeType.InfraNode,
             name: shape.name,
             provider: "self",
             kind: "zod-schema"
@@ -14043,14 +14696,14 @@ async function addZodShapes(graph, services) {
         }
         if (shape.fields.length > 0) {
           const node = graph.getNodeAttributes(shape.infraId);
-          if (node.type === import_types48.NodeType.InfraNode) {
+          if (node.type === import_types51.NodeType.InfraNode) {
             graph.replaceNodeAttributes(shape.infraId, {
               ...node,
               columns: foldColumns(
                 node.columns,
                 shape.fields,
-                import_types48.Provenance.EXTRACTED,
-                (0, import_types48.confidenceForExtracted)("structural")
+                import_types51.Provenance.EXTRACTED,
+                (0, import_types51.confidenceForExtracted)("structural")
               )
             });
           }
@@ -14064,15 +14717,15 @@ async function addZodShapes(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        const edgeId = (0, import_types48.extractedEdgeId)(fileNodeId, shape.infraId, import_types48.EdgeType.CONTAINS);
+        const edgeId = (0, import_types51.extractedEdgeId)(fileNodeId, shape.infraId, import_types51.EdgeType.CONTAINS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: shape.infraId,
-            type: import_types48.EdgeType.CONTAINS,
-            provenance: import_types48.Provenance.EXTRACTED,
-            confidence: (0, import_types48.confidenceForExtracted)("structural"),
+            type: import_types51.EdgeType.CONTAINS,
+            provenance: import_types51.Provenance.EXTRACTED,
+            confidence: (0, import_types51.confidenceForExtracted)("structural"),
             evidence: shape.evidence
           };
           graph.addEdgeWithKey(edgeId, fileNodeId, shape.infraId, edge);
@@ -14086,7 +14739,7 @@ async function addZodShapes(graph, services) {
 
 // src/extract/firestore-rules.ts
 init_cjs_shims();
-var import_types49 = require("@neat.is/types");
+var import_types52 = require("@neat.is/types");
 var FIRESTORE_COLLECTION_KIND = "firestore-collection";
 var WRITE_METHODS = /* @__PURE__ */ new Set(["write", "create", "update"]);
 function stripComments(src) {
@@ -14226,7 +14879,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_types49.NodeType.InfraNode) return;
+    if (node.type !== import_types52.NodeType.InfraNode) return;
     if (node.kind !== FIRESTORE_COLLECTION_KIND) return;
     const fields = guards.get(collectionKeyFromName(node.name));
     if (!fields || fields.size === 0) return;
@@ -14239,17 +14892,17 @@ async function addFirestoreRules(graph, services) {
 }
 
 // src/extract/index.ts
-var import_node_path61 = __toESM(require("path"), 1);
+var import_node_path64 = __toESM(require("path"), 1);
 
 // src/extract/retire.ts
 init_cjs_shims();
-var import_node_fs27 = require("fs");
-var import_node_path60 = __toESM(require("path"), 1);
-var import_types50 = require("@neat.is/types");
+var import_node_fs30 = require("fs");
+var import_node_path63 = __toESM(require("path"), 1);
+var import_types53 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
   graph.forEachNode((id, attrs) => {
-    if (attrs.type !== import_types50.NodeType.FileNode) return;
+    if (attrs.type !== import_types53.NodeType.FileNode) return;
     if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
       orphans.push(id);
     }
@@ -14262,14 +14915,14 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
   const bases = [scanPath, ...serviceDirs];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== import_types50.Provenance.EXTRACTED) return;
+    if (edge.provenance !== import_types53.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (import_node_path60.default.isAbsolute(evidenceFile)) {
-      if (!(0, import_node_fs27.existsSync)(evidenceFile)) toDrop.push(id);
+    if (import_node_path63.default.isAbsolute(evidenceFile)) {
+      if (!(0, import_node_fs30.existsSync)(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => (0, import_node_fs27.existsSync)(import_node_path60.default.join(base, evidenceFile)));
+    const found = bases.some((base) => (0, import_node_fs30.existsSync)(import_node_path63.default.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -14326,7 +14979,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   }
   const droppedEntries = drainDroppedExtracted();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = import_node_path61.default.join(import_node_path61.default.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = import_node_path64.default.join(import_node_path64.default.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -14360,7 +15013,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 
 // src/diff.ts
 init_cjs_shims();
-var import_node_fs28 = require("fs");
+var import_node_fs31 = require("fs");
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -14369,7 +15022,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await import_node_fs28.promises.readFile(target, "utf8");
+  const raw = await import_node_fs31.promises.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -14437,9 +15090,9 @@ function canonicalJson(value) {
 
 // src/persist.ts
 init_cjs_shims();
-var import_node_fs29 = require("fs");
-var import_node_path62 = __toESM(require("path"), 1);
-var import_types51 = require("@neat.is/types");
+var import_node_fs32 = require("fs");
+var import_node_path65 = __toESM(require("path"), 1);
+var import_types54 = require("@neat.is/types");
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -14463,7 +15116,7 @@ function migrateV5ToV6(payload) {
   if (Array.isArray(nodes)) {
     for (const node of nodes) {
       const attrs = node.attributes;
-      if (!attrs || attrs.type !== import_types51.NodeType.InfraNode) continue;
+      if (!attrs || attrs.type !== import_types54.NodeType.InfraNode) continue;
       if (attrs.kind !== "sql-table" && attrs.kind !== "supabase-table") continue;
       if (!Array.isArray(attrs.columns)) attrs.columns = [];
     }
@@ -14479,12 +15132,12 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = import_types51.Provenance.OBSERVED;
+      attrs.provenance = import_types54.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_types51.observedEdgeId)(source, target, type);
+        const newId = (0, import_types54.observedEdgeId)(source, target, type);
         attrs.id = newId;
         if (edge.key) edge.key = newId;
       }
@@ -14493,7 +15146,7 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await import_node_fs29.promises.mkdir(import_node_path62.default.dirname(filePath), { recursive: true });
+  await import_node_fs32.promises.mkdir(import_node_path65.default.dirname(filePath), { recursive: true });
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -14503,13 +15156,13 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await import_node_fs29.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await import_node_fs29.promises.rename(tmp, outPath);
+  await import_node_fs32.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
+  await import_node_fs32.promises.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await import_node_fs29.promises.readFile(outPath, "utf8");
+    raw = await import_node_fs32.promises.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -14583,23 +15236,23 @@ function startPersistLoop(graph, outPath, opts = {}) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_path63 = __toESM(require("path"), 1);
+var import_node_path66 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path63.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path63.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path63.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path63.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path63.default.join(baseDir, "policy-violations.ndjson")
+      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")
     };
   }
   return {
-    snapshotPath: import_node_path63.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path63.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path63.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path63.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path63.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    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`)
   };
 }
 var Projects = class {
@@ -14639,20 +15292,20 @@ function parseExtraProjects(raw) {
 
 // src/registry.ts
 init_cjs_shims();
-var import_node_fs30 = require("fs");
+var import_node_fs33 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path64 = __toESM(require("path"), 1);
-var import_types52 = require("@neat.is/types");
+var import_node_path67 = __toESM(require("path"), 1);
+var import_types55 = require("@neat.is/types");
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path64.default.resolve(override);
-  return import_node_path64.default.join(import_node_os3.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path67.default.resolve(override);
+  return import_node_path67.default.join(import_node_os3.default.homedir(), ".neat");
 }
 function registryPath() {
-  return import_node_path64.default.join(neatHome(), "projects.json");
+  return import_node_path67.default.join(neatHome(), "projects.json");
 }
 function daemonsDir() {
-  return import_node_path64.default.join(neatHome(), "daemons");
+  return import_node_path67.default.join(neatHome(), "daemons");
 }
 function isFiniteInt(v) {
   return typeof v === "number" && Number.isFinite(v);
@@ -14685,7 +15338,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const dir = daemonsDir();
   let names;
   try {
-    names = await import_node_fs30.promises.readdir(dir);
+    names = await import_node_fs33.promises.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -14693,10 +15346,10 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const file = import_node_path64.default.join(dir, name);
+    const file = import_node_path67.default.join(dir, name);
     let raw;
     try {
-      raw = await import_node_fs30.promises.readFile(file, "utf8");
+      raw = await import_node_fs33.promises.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -14724,7 +15377,7 @@ async function readRegistry() {
   const file = registryPath();
   let raw;
   try {
-    raw = await import_node_fs30.promises.readFile(file, "utf8");
+    raw = await import_node_fs33.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: 1, projects: [] };
@@ -14732,7 +15385,7 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types52.RegistryFileSchema.parse(parsed);
+  return import_types55.RegistryFileSchema.parse(parsed);
 }
 async function getProject(name) {
   const reg = await readRegistry();
@@ -14807,8 +15460,8 @@ init_auth();
 // src/connectors-config.ts
 init_cjs_shims();
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path65 = __toESM(require("path"), 1);
-var import_node_fs31 = require("fs");
+var import_node_path68 = __toESM(require("path"), 1);
+var import_node_fs34 = require("fs");
 var CONNECTORS_CONFIG_VERSION = 1;
 var EnvRefUnsetError = class extends Error {
   ref;
@@ -14822,17 +15475,17 @@ var EnvRefUnsetError = class extends Error {
 };
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path65.default.resolve(override);
-  return import_node_path65.default.join(import_node_os4.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path68.default.resolve(override);
+  return import_node_path68.default.join(import_node_os4.default.homedir(), ".neat");
 }
 function connectorsConfigPath(home = neatHome2()) {
-  return import_node_path65.default.join(home, "connectors.json");
+  return import_node_path68.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_fs31.promises.stat(file);
+    const stat = await import_node_fs34.promises.stat(file);
     if ((stat.mode & MODE_MASK_LOOSER_THAN_0600) !== 0) {
       const mode = (stat.mode & 511).toString(8).padStart(3, "0");
       console.warn(
@@ -14846,7 +15499,7 @@ async function readConnectorsConfig(home = neatHome2()) {
   const file = connectorsConfigPath(home);
   let raw;
   try {
-    raw = await import_node_fs31.promises.readFile(file, "utf8");
+    raw = await import_node_fs34.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: CONNECTORS_CONFIG_VERSION, connectors: [] };
@@ -15013,15 +15666,15 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 
 // src/connectors/index.ts
 init_cjs_shims();
-var import_types53 = require("@neat.is/types");
+var import_types56 = 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_types53.Provenance.EXTRACTED) continue;
-    const parsed = (0, import_types53.parseFileId)(edge.source);
+    if (edge.provenance !== import_types56.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types56.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;
@@ -15032,7 +15685,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_types53.NodeType.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== import_types56.NodeType.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -15489,10 +16142,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(path68) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path68);
+function targetFromRestPath(path71) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path71);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path68);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path71);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -15603,23 +16256,23 @@ async function fetchPgStatStatements(connectionString, limit = DEFAULT_STATEMENT
 
 // src/connectors/supabase/resolve.ts
 init_cjs_shims();
-var import_types55 = require("@neat.is/types");
+var import_types58 = 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_types55.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
+    const subResourceId = (0, import_types58.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
     if (graph.hasNode(subResourceId)) {
-      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types55.EdgeType.CALLS };
+      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types58.EdgeType.CALLS };
     }
-    const bareResourceId = (0, import_types55.infraId)(signal.targetKind, signal.targetName);
+    const bareResourceId = (0, import_types58.infraId)(signal.targetKind, signal.targetName);
     if (graph.hasNode(bareResourceId)) {
-      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types55.EdgeType.CALLS };
+      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types58.EdgeType.CALLS };
     }
-    const projectLevelId = (0, import_types55.infraId)("supabase", config.nodeRef);
+    const projectLevelId = (0, import_types58.infraId)("supabase", config.nodeRef);
     if (graph.hasNode(projectLevelId)) {
-      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types55.EdgeType.CALLS };
+      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types58.EdgeType.CALLS };
     }
     return null;
   };
@@ -15712,7 +16365,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 
 // src/connectors/railway/index.ts
 init_cjs_shims();
-var import_types59 = require("@neat.is/types");
+var import_types62 = require("@neat.is/types");
 
 // src/connectors/railway/client.ts
 init_cjs_shims();
@@ -15863,7 +16516,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types59.NodeType.RouteNode) return;
+    if (node.type !== import_types62.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -15967,12 +16620,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_types59.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types62.EdgeType.CALLS };
     }
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: (0, import_types59.serviceId)(peerName), serviceName, edgeType: import_types59.EdgeType.CONNECTS_TO };
+      return { targetNodeId: (0, import_types62.serviceId)(peerName), serviceName, edgeType: import_types62.EdgeType.CONNECTS_TO };
     }
     return null;
   };
@@ -16096,9 +16749,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path68 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path68) return null;
-  return { resourceName, method, path: path68 };
+  const path71 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path71) return null;
+  return { resourceName, method, path: path71 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -16136,14 +16789,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 path68 = pathFromRequestUrl(req.requestUrl);
-  if (path68 === null) return null;
+  const path71 = pathFromRequestUrl(req.requestUrl);
+  if (path71 === 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: path68 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path71 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -16160,7 +16813,7 @@ function mapLogEntriesToSignals(entries) {
 
 // src/connectors/firebase/resolve.ts
 init_cjs_shims();
-var import_types60 = require("@neat.is/types");
+var import_types63 = require("@neat.is/types");
 function neatServiceNameFor(resourceType, resourceName, serviceMap) {
   switch (resourceType) {
     case "cloud_function":
@@ -16175,7 +16828,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types60.NodeType.RouteNode) return;
+    if (node.type !== import_types63.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -16207,7 +16860,7 @@ function createFirebaseResolveTarget(graph, serviceMap) {
     return {
       targetNodeId: match.routeNodeId,
       serviceName,
-      edgeType: import_types60.EdgeType.CALLS
+      edgeType: import_types63.EdgeType.CALLS
     };
   };
 }
@@ -16234,7 +16887,7 @@ init_cjs_shims();
 
 // src/connectors/cloudflare/connector.ts
 init_cjs_shims();
-var import_types62 = require("@neat.is/types");
+var import_types65 = require("@neat.is/types");
 
 // src/connectors/cloudflare/client.ts
 init_cjs_shims();
@@ -16350,7 +17003,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 path68 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path71 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -16358,7 +17011,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path68 ? { path: path68 } : {},
+    ...path71 ? { path: path71 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -16398,19 +17051,19 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === import_types62.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === import_types65.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path68) {
-  const normalizedPath = normalizePathTemplate(path68);
+function findMatchingRouteNode(graph, serviceName, method, path71) {
+  const normalizedPath = normalizePathTemplate(path71);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types62.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types65.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;
@@ -16422,18 +17075,18 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path68 } = signal;
+    const { method, path: path71 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path68) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path68) ?? wholeFileId;
+      if (!method || !path71) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path71) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
-      const wholeFileId = (0, import_types62.fileId)(mapping.service, mapping.entryFile);
+      const wholeFileId = (0, import_types65.fileId)(mapping.service, mapping.entryFile);
       return {
         targetNodeId: resolveRouteGrain(mapping.service, wholeFileId),
         serviceName: mapping.service,
-        edgeType: import_types62.EdgeType.CALLS
+        edgeType: import_types65.EdgeType.CALLS
       };
     }
     const taggedFileId = findTaggedWorkerFileNode(graph, scriptName);
@@ -16442,13 +17095,13 @@ function createCloudflareResolveTarget(config, graph) {
       return {
         targetNodeId: resolveRouteGrain(fileNode.service, taggedFileId),
         serviceName: fileNode.service,
-        edgeType: import_types62.EdgeType.CALLS
+        edgeType: import_types65.EdgeType.CALLS
       };
     }
     return {
-      targetNodeId: (0, import_types62.infraId)("cloudflare-worker", scriptName),
+      targetNodeId: (0, import_types65.infraId)("cloudflare-worker", scriptName),
       serviceName: scriptName,
-      edgeType: import_types62.EdgeType.CALLS,
+      edgeType: import_types65.EdgeType.CALLS,
       ensureInfraNode: { kind: "cloudflare-worker", name: scriptName, provider: "cloudflare" }
     };
   };
@@ -16644,14 +17297,14 @@ function diffNeonStatementsToSignals(rows, previous, observedAtIso) {
 
 // src/connectors/neon/resolve.ts
 init_cjs_shims();
-var import_types66 = require("@neat.is/types");
+var import_types69 = 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_types66.infraId)("sql-table", signal.targetName),
+      targetNodeId: (0, import_types69.infraId)("sql-table", signal.targetName),
       serviceName: config.serviceName,
-      edgeType: import_types66.EdgeType.CALLS,
+      edgeType: import_types69.EdgeType.CALLS,
       ensureInfraNode: { kind: "sql-table", name: signal.targetName, provider: "neon" }
     };
   };
@@ -16777,9 +17430,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path68 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path68) return null;
-  return { serviceName, method, path: path68 };
+  const path71 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path71) return null;
+  return { serviceName, method, path: path71 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -16808,14 +17461,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 path68 = pathFromRequestUrl2(req.requestUrl);
-  if (path68 === null) return null;
+  const path71 = pathFromRequestUrl2(req.requestUrl);
+  if (path71 === 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: path68 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path71 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -16832,14 +17485,14 @@ function mapLogEntriesToSignals2(entries) {
 
 // src/connectors/cloud-run/resolve.ts
 init_cjs_shims();
-var import_types70 = require("@neat.is/types");
+var import_types73 = 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_types70.NodeType.RouteNode) return;
+    if (node.type !== import_types73.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -16854,23 +17507,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: path68 } = identity;
+    const { serviceName: gcpServiceName, method, path: path71 } = identity;
     const mappedService = config.serviceMap?.[gcpServiceName];
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path68)
+        normalizePathTemplate(path71)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types70.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types73.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types70.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
+      targetNodeId: (0, import_types73.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
       serviceName: mappedService ?? gcpServiceName,
-      edgeType: import_types70.EdgeType.CALLS,
+      edgeType: import_types73.EdgeType.CALLS,
       ensureInfraNode: {
         kind: CLOUD_RUN_SERVICE_INFRA_KIND,
         name: gcpServiceName,
@@ -16911,7 +17564,7 @@ function createCloudRunConnector(graph, config = {}) {
 
 // src/connectors/render/index.ts
 init_cjs_shims();
-var import_types73 = require("@neat.is/types");
+var import_types76 = require("@neat.is/types");
 
 // src/connectors/render/types.ts
 init_cjs_shims();
@@ -16989,7 +17642,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     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) return;
     out.push({
@@ -17074,7 +17727,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_types73.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types76.EdgeType.CALLS };
     }
     return null;
   };
@@ -17212,21 +17865,21 @@ function mapInsightsToSignals(rows, observedAtIso) {
 
 // src/connectors/planetscale/resolve.ts
 init_cjs_shims();
-var import_types77 = require("@neat.is/types");
+var import_types80 = 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_types77.infraId)("sql-table", signal.targetName);
+    const tableId = (0, import_types80.infraId)("sql-table", signal.targetName);
     if (graph.hasNode(tableId)) {
-      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types77.EdgeType.CALLS };
+      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types80.EdgeType.CALLS };
     }
-    const providerId = (0, import_types77.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
+    const providerId = (0, import_types80.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
     return {
       targetNodeId: providerId,
       serviceName: config.serviceName,
-      edgeType: import_types77.EdgeType.CALLS,
+      edgeType: import_types80.EdgeType.CALLS,
       ensureInfraNode: { kind: PLANETSCALE_DATABASE_KIND, name: databaseName, provider: "planetscale" }
     };
   };
@@ -17491,7 +18144,7 @@ function mapBuildsToSignals(builds, serviceName) {
 
 // src/connectors/eas/resolve.ts
 init_cjs_shims();
-var import_types82 = require("@neat.is/types");
+var import_types85 = 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([
@@ -17507,8 +18160,8 @@ function configBasenamesForPhase(phase) {
 function configNodeService(graph, configNodeId) {
   for (const edgeId of graph.inboundEdges(configNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types82.EdgeType.CONFIGURED_BY) continue;
-    const parsed = (0, import_types82.parseFileId)(edge.source);
+    if (edge.type !== import_types85.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types85.parseFileId)(edge.source);
     if (parsed) return parsed.service;
   }
   return null;
@@ -17519,7 +18172,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== import_types82.NodeType.ConfigNode) return;
+    if (node.type !== import_types85.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;
@@ -17536,13 +18189,13 @@ function createEasResolveTarget(graph) {
     if (basenames.length > 0) {
       const configNodeId = findConfigNode(graph, basenames, serviceName);
       if (configNodeId) {
-        return { targetNodeId: configNodeId, serviceName, edgeType: import_types82.EdgeType.CALLS };
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types85.EdgeType.CALLS };
       }
     }
     return {
       targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
       serviceName,
-      edgeType: import_types82.EdgeType.CALLS
+      edgeType: import_types85.EdgeType.CALLS
     };
   };
 }
@@ -18221,11 +18874,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_types85.DivergenceTypeSchema.safeParse(c);
+        const r = import_types88.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types85.DivergenceTypeSchema.options
+            allowed: import_types88.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -18567,7 +19220,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types85.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types88.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -18606,7 +19259,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_types85.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types88.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -18927,8 +19580,8 @@ init_otel_grpc();
 
 // src/search.ts
 init_cjs_shims();
-var import_node_fs32 = require("fs");
-var import_node_path66 = __toESM(require("path"), 1);
+var import_node_fs35 = require("fs");
+var import_node_path69 = __toESM(require("path"), 1);
 var import_node_crypto4 = require("crypto");
 var DEFAULT_LIMIT = 10;
 var NOMIC_DIM = 768;
@@ -19082,7 +19735,7 @@ async function pickEmbedder() {
 }
 async function readCache(cachePath) {
   try {
-    const raw = await import_node_fs32.promises.readFile(cachePath, "utf8");
+    const raw = await import_node_fs35.promises.readFile(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return null;
     return parsed;
@@ -19091,8 +19744,8 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  await import_node_fs32.promises.mkdir(import_node_path66.default.dirname(cachePath), { recursive: true });
-  await import_node_fs32.promises.writeFile(cachePath, JSON.stringify(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));
 }
 var VectorIndex = class {
   constructor(embedder, cachePath) {
@@ -19306,14 +19959,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_path67.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path67.default.resolve(import_node_path67.default.dirname(legacyOutPath)) : import_node_path67.default.resolve("./neat-out");
-  const defaultScanPath = import_node_path67.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
+  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 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_path67.default.resolve(projectScan) : void 0, baseDir);
+    await bootProject(registry, name, projectScan ? import_node_path70.default.resolve(projectScan) : void 0, baseDir);
   }
   const host = process.env.HOST ?? "0.0.0.0";
   const port = Number(process.env.PORT ?? 8080);