@neat.is/core 0.4.6 → 0.4.7

package/dist/{chunk-RBWL4HRB.js → chunk-7FTK47JQ.js}

@@ -1027,6 +1027,7 @@ import {
   confidenceForObservedSignal,
   databaseId,
   extractedEdgeId,
+  fileId,
   frontierId,
   inferredEdgeId,
   observedEdgeId,
@@ -1094,6 +1095,86 @@ function hostFromUrl(u) {
 function pickAddress(span) {
   return pickAttr(span, "server.address", "net.peer.name", "net.host.name") ?? hostFromUrl(pickAttr(span, "url.full", "http.url"));
 }
+var CODE_FILEPATH_ATTR = "code.filepath";
+var CODE_LINENO_ATTR = "code.lineno";
+var CODE_FUNCTION_ATTR = "code.function";
+function toPosix(p) {
+  return p.split("\\").join("/");
+}
+function languageForExt(relPath) {
+  const dot = relPath.lastIndexOf(".");
+  if (dot === -1) return void 0;
+  switch (relPath.slice(dot).toLowerCase()) {
+    case ".py":
+      return "python";
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    default:
+      return void 0;
+  }
+}
+function relPathForRuntimeFile(filepath, serviceNode) {
+  let p = toPosix(filepath).replace(/^file:\/\//, "");
+  const root = serviceNode?.repoPath;
+  if (root && root !== "." && root.length > 0) {
+    const rootPosix = toPosix(root);
+    const anchor = `/${rootPosix}/`;
+    const idx = p.lastIndexOf(anchor);
+    if (idx !== -1) return p.slice(idx + anchor.length);
+    const base = rootPosix.split("/").filter(Boolean).pop();
+    if (base) {
+      const baseAnchor = `/${base}/`;
+      const bidx = p.lastIndexOf(baseAnchor);
+      if (bidx !== -1) return p.slice(bidx + baseAnchor.length);
+    }
+  }
+  p = p.replace(/^[A-Za-z]:/, "").replace(/^\/+/, "");
+  return p.length > 0 ? p : null;
+}
+function callSiteFromSpan(span, serviceNode) {
+  const filepath = span.attributes[CODE_FILEPATH_ATTR];
+  if (typeof filepath !== "string" || filepath.length === 0) return null;
+  const relPath = relPathForRuntimeFile(filepath, serviceNode);
+  if (!relPath) return null;
+  const linenoRaw = span.attributes[CODE_LINENO_ATTR];
+  const line = typeof linenoRaw === "number" && Number.isFinite(linenoRaw) ? linenoRaw : void 0;
+  const fnRaw = span.attributes[CODE_FUNCTION_ATTR];
+  const fn = typeof fnRaw === "string" && fnRaw.length > 0 ? fnRaw : void 0;
+  return { relPath, ...line !== void 0 ? { line } : {}, ...fn ? { fn } : {} };
+}
+function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
+  const fileNodeId = fileId(serviceName, callSite.relPath);
+  if (!graph.hasNode(fileNodeId)) {
+    const language = languageForExt(callSite.relPath);
+    const node = {
+      id: fileNodeId,
+      type: NodeType3.FileNode,
+      service: serviceName,
+      path: callSite.relPath,
+      ...language ? { language } : {},
+      discoveredVia: "otel"
+    };
+    graph.addNode(fileNodeId, node);
+  }
+  const containsId = makeObservedEdgeId(EdgeType2.CONTAINS, serviceNodeId, fileNodeId);
+  if (!graph.hasEdge(containsId)) {
+    const edge = {
+      id: containsId,
+      source: serviceNodeId,
+      target: fileNodeId,
+      type: EdgeType2.CONTAINS,
+      provenance: Provenance.OBSERVED
+    };
+    graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
+  }
+  return fileNodeId;
+}
 function makeObservedEdgeId(type, source, target) {
   return observedEdgeId(source, target, type);
 }
@@ -1336,6 +1417,9 @@ async function handleSpan(ctx, span) {
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = span.statusCode === 2;
   cacheSpanService(span, nowMs);
+  const sourceServiceNode = ctx.graph.getNodeAttributes(sourceId);
+  const callSite = callSiteFromSpan(span, sourceServiceNode);
+  const observedSource = () => callSite ? ensureObservedFileNode(ctx.graph, span.service, sourceId, callSite) : sourceId;
   let affectedNode = sourceId;
   if (span.dbSystem) {
     const host = pickAddress(span);
@@ -1345,7 +1429,7 @@ async function handleSpan(ctx, span) {
       const result = upsertObservedEdge(
         ctx.graph,
         EdgeType2.CONNECTS_TO,
-        sourceId,
+        observedSource(),
         targetId,
         ts,
         isError
@@ -1361,7 +1445,7 @@ async function handleSpan(ctx, span) {
         upsertObservedEdge(
           ctx.graph,
           EdgeType2.CALLS,
-          sourceId,
+          observedSource(),
           targetId,
           ts,
           isError
@@ -1373,7 +1457,7 @@ async function handleSpan(ctx, span) {
         upsertObservedEdge(
           ctx.graph,
           EdgeType2.CALLS,
-          sourceId,
+          observedSource(),
           frontierNodeId,
           ts,
           isError
@@ -3010,10 +3094,10 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/calls/index.ts
 import {
-  EdgeType as EdgeType6,
-  NodeType as NodeType8,
-  Provenance as Provenance5,
-  confidenceForExtracted as confidenceForExtracted4,
+  EdgeType as EdgeType7,
+  NodeType as NodeType9,
+  Provenance as Provenance6,
+  confidenceForExtracted as confidenceForExtracted5,
   passesExtractedFloor as passesExtractedFloor2
 } from "@neat.is/types";
 
@@ -3023,15 +3107,23 @@ import Parser from "tree-sitter";
 import JavaScript from "tree-sitter-javascript";
 import Python from "tree-sitter-python";
 import {
-  EdgeType as EdgeType5,
-  Provenance as Provenance4,
-  confidenceForExtracted as confidenceForExtracted3,
+  EdgeType as EdgeType6,
+  Provenance as Provenance5,
+  confidenceForExtracted as confidenceForExtracted4,
   passesExtractedFloor
 } from "@neat.is/types";
 
 // src/extract/calls/shared.ts
 import { promises as fs13 } from "fs";
 import path19 from "path";
+import {
+  EdgeType as EdgeType5,
+  NodeType as NodeType8,
+  Provenance as Provenance4,
+  confidenceForExtracted as confidenceForExtracted3,
+  extractedEdgeId as extractedEdgeId3,
+  fileId as fileId2
+} from "@neat.is/types";
 async function walkSourceFiles(dir) {
   const out = [];
   async function walk(current) {
@@ -3071,6 +3163,58 @@ function snippet(text, line) {
   const lines = text.split("\n");
   return (lines[line - 1] ?? "").trim();
 }
+function toPosix2(p) {
+  return p.split("\\").join("/");
+}
+function languageForPath(relPath) {
+  switch (path19.extname(relPath).toLowerCase()) {
+    case ".py":
+      return "python";
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    default:
+      return void 0;
+  }
+}
+function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
+  let nodesAdded = 0;
+  let edgesAdded = 0;
+  const fileNodeId = fileId2(serviceName, relPath);
+  if (!graph.hasNode(fileNodeId)) {
+    const language = languageForPath(relPath);
+    const node = {
+      id: fileNodeId,
+      type: NodeType8.FileNode,
+      service: serviceName,
+      path: relPath,
+      ...language ? { language } : {},
+      discoveredVia: "static"
+    };
+    graph.addNode(fileNodeId, node);
+    nodesAdded++;
+  }
+  const containsId = extractedEdgeId3(serviceNodeId, fileNodeId, EdgeType5.CONTAINS);
+  if (!graph.hasEdge(containsId)) {
+    const edge = {
+      id: containsId,
+      source: serviceNodeId,
+      target: fileNodeId,
+      type: EdgeType5.CONTAINS,
+      provenance: Provenance4.EXTRACTED,
+      confidence: confidenceForExtracted3("structural"),
+      evidence: { file: relPath }
+    };
+    graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
+    edgesAdded++;
+  }
+  return { fileNodeId, nodesAdded, edgesAdded };
+}
 
 // src/extract/calls/http.ts
 var STRING_LITERAL_NODE_TYPES = /* @__PURE__ */ new Set(["string_fragment", "string_content"]);
@@ -3104,16 +3248,16 @@ function callsFromSource(source, parser, knownHosts) {
   const tree = parser.parse(source);
   const literals = [];
   collectStringLiterals(tree.rootNode, literals);
-  const targets = /* @__PURE__ */ new Set();
+  const out = [];
   for (const lit of literals) {
     if (isInsideJsxExternalLink(lit.node)) continue;
     for (const host of knownHosts) {
       if (urlMatchesHost(lit.text, host)) {
-        targets.add(host);
+        out.push({ host, line: lit.node.startPosition.row + 1 });
       }
     }
   }
-  return targets;
+  return out;
 }
 function makeJsParser() {
   const p = new Parser();
@@ -3136,65 +3280,72 @@ async function addHttpCallEdges(graph, services) {
     hostToNodeId.set(path20.basename(service.dir), service.node.id);
     hostToNodeId.set(service.pkg.name, service.node.id);
   }
+  let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
     const files = await loadSourceFiles(service.dir);
-    const seenTargets = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
       const parser = path20.extname(file.path) === ".py" ? pyParser : jsParser;
-      let targets;
+      let sites;
       try {
-        targets = callsFromSource(file.content, parser, knownHosts);
+        sites = callsFromSource(file.content, parser, knownHosts);
       } catch (err) {
         recordExtractionError("http call extraction", file.path, err);
         continue;
       }
-      for (const t of targets) {
-        const targetId = hostToNodeId.get(t);
+      if (sites.length === 0) continue;
+      const relFile = toPosix2(path20.relative(service.dir, file.path));
+      for (const site of sites) {
+        const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
-        if (!seenTargets.has(targetId)) {
-          seenTargets.set(targetId, { file: file.path, host: t });
+        const dedupKey = `${relFile}|${targetId}`;
+        if (seen.has(dedupKey)) continue;
+        seen.add(dedupKey);
+        const confidence = confidenceForExtracted4("hostname-shape-match");
+        const ev = {
+          file: relFile,
+          line: site.line,
+          snippet: snippet(file.content, site.line)
+        };
+        if (!passesExtractedFloor(confidence)) {
+          noteExtractedDropped({
+            source: service.node.id,
+            target: targetId,
+            type: EdgeType6.CALLS,
+            confidence,
+            confidenceKind: "hostname-shape-match",
+            evidence: ev
+          });
+          continue;
+        }
+        const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
+          graph,
+          service.pkg.name,
+          service.node.id,
+          relFile
+        );
+        nodesAdded += n;
+        edgesAdded += e;
+        const edgeId = extractedEdgeId2(fileNodeId, targetId, EdgeType6.CALLS);
+        if (!graph.hasEdge(edgeId)) {
+          const edge = {
+            id: edgeId,
+            source: fileNodeId,
+            target: targetId,
+            type: EdgeType6.CALLS,
+            provenance: Provenance5.EXTRACTED,
+            confidence,
+            evidence: ev
+          };
+          graph.addEdgeWithKey(edgeId, fileNodeId, targetId, edge);
+          edgesAdded++;
         }
-      }
-    }
-    for (const [targetId, evidenceFile] of seenTargets) {
-      const fileContent = files.find((f) => f.path === evidenceFile.file)?.content ?? "";
-      const line = lineOf(fileContent, `//${evidenceFile.host}`);
-      const confidence = confidenceForExtracted3("hostname-shape-match");
-      const ev = {
-        file: path20.relative(service.dir, evidenceFile.file),
-        line,
-        snippet: snippet(fileContent, line)
-      };
-      const edgeId = extractedEdgeId2(service.node.id, targetId, EdgeType5.CALLS);
-      if (!passesExtractedFloor(confidence)) {
-        noteExtractedDropped({
-          source: service.node.id,
-          target: targetId,
-          type: EdgeType5.CALLS,
-          confidence,
-          confidenceKind: "hostname-shape-match",
-          evidence: ev
-        });
-        continue;
-      }
-      const edge = {
-        id: edgeId,
-        source: service.node.id,
-        target: targetId,
-        type: EdgeType5.CALLS,
-        provenance: Provenance4.EXTRACTED,
-        confidence,
-        evidence: ev
-      };
-      if (!graph.hasEdge(edge.id)) {
-        graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
-        edgesAdded++;
       }
     }
   }
-  return edgesAdded;
+  return { nodesAdded, edgesAdded };
 }
 
 // src/extract/calls/kafka.ts
@@ -3403,11 +3554,11 @@ function grpcEndpointsFromFile(file, serviceDir) {
 function edgeTypeFromEndpoint(ep) {
   switch (ep.edgeType) {
     case "PUBLISHES_TO":
-      return EdgeType6.PUBLISHES_TO;
+      return EdgeType7.PUBLISHES_TO;
     case "CONSUMES_FROM":
-      return EdgeType6.CONSUMES_FROM;
+      return EdgeType7.CONSUMES_FROM;
     default:
-      return EdgeType6.CALLS;
+      return EdgeType7.CALLS;
   }
 }
 function isAwsKind(kind) {
@@ -3434,7 +3585,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: NodeType8.InfraNode,
+          type: NodeType9.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -3446,10 +3597,7 @@ async function addExternalEndpointEdges(graph, services) {
         nodesAdded++;
       }
       const edgeType = edgeTypeFromEndpoint(ep);
-      const edgeId = extractedEdgeId2(service.node.id, ep.infraId, edgeType);
-      if (seenEdges.has(edgeId)) continue;
-      seenEdges.add(edgeId);
-      const confidence = confidenceForExtracted4(ep.confidenceKind);
+      const confidence = confidenceForExtracted5(ep.confidenceKind);
       if (!passesExtractedFloor2(confidence)) {
         noteExtractedDropped({
           source: service.node.id,
@@ -3461,13 +3609,25 @@ async function addExternalEndpointEdges(graph, services) {
         });
         continue;
       }
+      const relFile = toPosix2(ep.evidence.file);
+      const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
+        graph,
+        service.pkg.name,
+        service.node.id,
+        relFile
+      );
+      nodesAdded += n;
+      edgesAdded += e;
+      const edgeId = extractedEdgeId2(fileNodeId, ep.infraId, edgeType);
+      if (seenEdges.has(edgeId)) continue;
+      seenEdges.add(edgeId);
       if (!graph.hasEdge(edgeId)) {
         const edge = {
           id: edgeId,
-          source: service.node.id,
+          source: fileNodeId,
           target: ep.infraId,
           type: edgeType,
-          provenance: Provenance5.EXTRACTED,
+          provenance: Provenance6.EXTRACTED,
           confidence,
           evidence: ep.evidence
         };
@@ -3479,24 +3639,24 @@ async function addExternalEndpointEdges(graph, services) {
   return { nodesAdded, edgesAdded };
 }
 async function addCallEdges(graph, services) {
-  const httpEdges = await addHttpCallEdges(graph, services);
+  const http = await addHttpCallEdges(graph, services);
   const ext = await addExternalEndpointEdges(graph, services);
   return {
-    nodesAdded: ext.nodesAdded,
-    edgesAdded: httpEdges + ext.edgesAdded
+    nodesAdded: http.nodesAdded + ext.nodesAdded,
+    edgesAdded: http.edgesAdded + ext.edgesAdded
   };
 }
 
 // src/extract/infra/docker-compose.ts
 import path25 from "path";
-import { EdgeType as EdgeType7, Provenance as Provenance6, confidenceForExtracted as confidenceForExtracted5 } from "@neat.is/types";
+import { EdgeType as EdgeType8, Provenance as Provenance7, confidenceForExtracted as confidenceForExtracted6 } from "@neat.is/types";
 
 // src/extract/infra/shared.ts
-import { NodeType as NodeType9, infraId as infraId5 } from "@neat.is/types";
+import { NodeType as NodeType10, infraId as infraId5 } from "@neat.is/types";
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
     id: infraId5(kind, name),
-    type: NodeType9.InfraNode,
+    type: NodeType10.InfraNode,
     name,
     provider,
     kind,
@@ -3575,15 +3735,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 = extractedEdgeId2(sourceId, targetId, EdgeType7.DEPENDS_ON);
+      const edgeId = extractedEdgeId2(sourceId, targetId, EdgeType8.DEPENDS_ON);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: sourceId,
         target: targetId,
-        type: EdgeType7.DEPENDS_ON,
-        provenance: Provenance6.EXTRACTED,
-        confidence: confidenceForExtracted5("structural"),
+        type: EdgeType8.DEPENDS_ON,
+        provenance: Provenance7.EXTRACTED,
+        confidence: confidenceForExtracted6("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -3596,7 +3756,7 @@ async function addComposeInfra(graph, scanPath, services) {
 // src/extract/infra/dockerfile.ts
 import path26 from "path";
 import { promises as fs14 } from "fs";
-import { EdgeType as EdgeType8, Provenance as Provenance7, confidenceForExtracted as confidenceForExtracted6 } from "@neat.is/types";
+import { EdgeType as EdgeType9, Provenance as Provenance8, confidenceForExtracted as confidenceForExtracted7 } from "@neat.is/types";
 function runtimeImage(content) {
   const lines = content.split("\n");
   let last = null;
@@ -3635,15 +3795,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const edgeId = extractedEdgeId2(service.node.id, node.id, EdgeType8.RUNS_ON);
+    const edgeId = extractedEdgeId2(service.node.id, node.id, EdgeType9.RUNS_ON);
     if (!graph.hasEdge(edgeId)) {
       const edge = {
         id: edgeId,
         source: service.node.id,
         target: node.id,
-        type: EdgeType8.RUNS_ON,
-        provenance: Provenance7.EXTRACTED,
-        confidence: confidenceForExtracted6("structural"),
+        type: EdgeType9.RUNS_ON,
+        provenance: Provenance8.EXTRACTED,
+        confidence: confidenceForExtracted7("structural"),
         evidence: {
           file: path26.relative(scanPath, dockerfilePath).split(path26.sep).join("/")
         }
@@ -3768,17 +3928,29 @@ import path30 from "path";
 // src/extract/retire.ts
 import { existsSync } from "fs";
 import path29 from "path";
-import { Provenance as Provenance8 } from "@neat.is/types";
+import { NodeType as NodeType11, Provenance as Provenance9 } from "@neat.is/types";
+function dropOrphanedFileNodes(graph) {
+  const orphans = [];
+  graph.forEachNode((id, attrs) => {
+    if (attrs.type !== NodeType11.FileNode) return;
+    if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
+      orphans.push(id);
+    }
+  });
+  for (const id of orphans) graph.dropNode(id);
+  return orphans.length;
+}
 function retireEdgesByFile(graph, file) {
   const normalized = file.split("\\").join("/");
   const toDrop = [];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== Provenance8.EXTRACTED) return;
+    if (edge.provenance !== Provenance9.EXTRACTED) return;
     if (!edge.evidence?.file) return;
     if (edge.evidence.file === normalized) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
+  dropOrphanedFileNodes(graph);
   return toDrop.length;
 }
 function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
@@ -3786,7 +3958,7 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
   const bases = [scanPath, ...serviceDirs];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== Provenance8.EXTRACTED) return;
+    if (edge.provenance !== Provenance9.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
     if (path29.isAbsolute(evidenceFile)) {
@@ -3797,6 +3969,7 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
+  dropOrphanedFileNodes(graph);
   return toDrop.length;
 }
 
@@ -3865,10 +4038,10 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 // src/divergences.ts
 import {
   DivergenceResultSchema,
-  EdgeType as EdgeType9,
-  NodeType as NodeType10,
+  EdgeType as EdgeType10,
+  NodeType as NodeType12,
   parseEdgeId,
-  Provenance as Provenance9
+  Provenance as Provenance10
 } from "@neat.is/types";
 function bucketKey(source, target, type) {
   return `${type}|${source}|${target}`;
@@ -3882,17 +4055,17 @@ function bucketEdges(graph) {
     const key = bucketKey(e.source, e.target, e.type);
     const cur = buckets.get(key) ?? { source: e.source, target: e.target, type: e.type };
     switch (provenance) {
-      case Provenance9.EXTRACTED:
+      case Provenance10.EXTRACTED:
         cur.extracted = e;
         break;
-      case Provenance9.OBSERVED:
+      case Provenance10.OBSERVED:
         cur.observed = e;
         break;
-      case Provenance9.INFERRED:
+      case Provenance10.INFERRED:
         cur.inferred = e;
         break;
       default:
-        if (e.provenance === Provenance9.STALE) cur.stale = e;
+        if (e.provenance === Provenance10.STALE) cur.stale = e;
     }
     buckets.set(key, cur);
   });
@@ -3901,7 +4074,7 @@ function bucketEdges(graph) {
 function nodeIsFrontier(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === NodeType10.FrontierNode;
+  return attrs.type === NodeType12.FrontierNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -3922,6 +4095,7 @@ function gradedConfidence(edge) {
 }
 function detectMissingDivergences(graph, bucket) {
   const out = [];
+  if (bucket.type === EdgeType10.CONTAINS) return out;
   if (bucket.extracted && !bucket.observed) {
     if (!nodeIsFrontier(graph, bucket.target)) {
       out.push({
@@ -3962,7 +4136,7 @@ function declaredHostFor(svc) {
 function hasExtractedConfiguredBy(graph, svcId) {
   for (const edgeId of graph.outboundEdges(svcId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === EdgeType9.CONFIGURED_BY && e.provenance === Provenance9.EXTRACTED) {
+    if (e.type === EdgeType10.CONFIGURED_BY && e.provenance === Provenance10.EXTRACTED) {
       return true;
     }
   }
@@ -3975,10 +4149,10 @@ function detectHostMismatch(graph, svcId, svc) {
   const out = [];
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== EdgeType9.CONNECTS_TO) continue;
-    if (edge.provenance !== Provenance9.OBSERVED) continue;
+    if (edge.type !== EdgeType10.CONNECTS_TO) continue;
+    if (edge.provenance !== Provenance10.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== NodeType10.DatabaseNode) continue;
+    if (target.type !== NodeType12.DatabaseNode) continue;
     const observedHost = target.host?.trim();
     if (!observedHost) continue;
     if (observedHost === declaredHost) continue;
@@ -4000,10 +4174,10 @@ function detectCompatDivergences(graph, svcId, svc) {
   const deps = svc.dependencies ?? {};
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== EdgeType9.CONNECTS_TO) continue;
-    if (edge.provenance !== Provenance9.OBSERVED) continue;
+    if (edge.type !== EdgeType10.CONNECTS_TO) continue;
+    if (edge.provenance !== Provenance10.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== NodeType10.DatabaseNode) continue;
+    if (target.type !== NodeType12.DatabaseNode) continue;
     for (const pair of compatPairs()) {
       if (pair.engine !== target.engine) continue;
       const declared = deps[pair.driver];
@@ -4064,7 +4238,7 @@ function computeDivergences(graph, opts = {}) {
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
-    if (n.type !== NodeType10.ServiceNode) return;
+    if (n.type !== NodeType12.ServiceNode) return;
     const svc = n;
     for (const d of detectHostMismatch(graph, nodeId, svc)) all.push(d);
     for (const d of detectCompatDivergences(graph, nodeId, svc)) all.push(d);
@@ -4107,7 +4281,7 @@ function computeDivergences(graph, opts = {}) {
 // src/persist.ts
 import { promises as fs17 } from "fs";
 import path31 from "path";
-import { Provenance as Provenance10, observedEdgeId as observedEdgeId2 } from "@neat.is/types";
+import { Provenance as Provenance11, observedEdgeId as observedEdgeId2 } from "@neat.is/types";
 var SCHEMA_VERSION = 4;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -4129,7 +4303,7 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = Provenance10.OBSERVED;
+      attrs.provenance = Provenance11.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;
@@ -5137,4 +5311,4 @@ export {
   removeProject,
   buildApi
 };
-//# sourceMappingURL=chunk-RBWL4HRB.js.map
+//# sourceMappingURL=chunk-7FTK47JQ.js.map