@neat.is/core 0.10.6-dev.20261009 → 0.10.6

package/dist/server.cjs

@@ -797,7 +797,7 @@ init_cjs_shims();
 var import_fastify2 = __toESM(require("fastify"), 1);
 var import_node_crypto6 = require("crypto");
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types103 = require("@neat.is/types");
+var import_types104 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -1144,7 +1144,7 @@ async function rollbackExtension(ctx, args) {
 
 // src/divergences.ts
 init_cjs_shims();
-var import_types9 = require("@neat.is/types");
+var import_types10 = require("@neat.is/types");
 
 // src/columns.ts
 init_cjs_shims();
@@ -2061,7 +2061,7 @@ var PolicyViolationsLog = class {
 };
 
 // src/ingest.ts
-var import_types7 = require("@neat.is/types");
+var import_types8 = require("@neat.is/types");
 
 // src/extract/routes.ts
 init_cjs_shims();
@@ -4821,6 +4821,92 @@ async function addRoutes(graph, services) {
   return { nodesAdded, edgesAdded };
 }
 
+// src/extract/source-baseline.ts
+init_cjs_shims();
+var import_types7 = require("@neat.is/types");
+var states = /* @__PURE__ */ new WeakMap();
+var REPOSITORY = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function validCommit(commit, repository) {
+  return !!commit && commit.repository === repository && /^[0-9a-f]{40}$/.test(commit.sha);
+}
+function stateOf(graph) {
+  let state = states.get(graph);
+  if (!state) {
+    state = { repos: /* @__PURE__ */ new Map(), active: /* @__PURE__ */ new Set(), conflicted: /* @__PURE__ */ new Set() };
+    states.set(graph, state);
+  }
+  return state;
+}
+function setEntry(state, repository, baseline, generation = /* @__PURE__ */ Symbol()) {
+  state.repos.set(repository, {
+    baseline,
+    generation,
+    services: state.repos.get(repository)?.services ?? /* @__PURE__ */ new Set()
+  });
+}
+function readSourceBaselines(graph) {
+  const state = states.get(graph);
+  if (!state) return [];
+  return [...state.repos.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, entry]) => ({ ...entry.baseline }));
+}
+function invalidateSourceBaseline(graph, repository, status2 = "unavailable") {
+  if (repository !== void 0) {
+    if (REPOSITORY.test(repository)) setEntry(stateOf(graph), repository, { status: status2, repository });
+    return;
+  }
+  const state = states.get(graph);
+  if (!state) return;
+  for (const generation of state.active) state.conflicted.add(generation);
+  for (const name of state.repos.keys()) {
+    setEntry(state, name, { status: "unavailable", repository: name });
+  }
+}
+function beginSourceExtraction(graph, source, commit) {
+  const generation = /* @__PURE__ */ Symbol();
+  const state = stateOf(graph);
+  if (source === void 0) {
+    invalidateSourceBaseline(graph);
+    state.active.add(generation);
+    return generation;
+  }
+  state.active.add(generation);
+  if (!REPOSITORY.test(source)) return generation;
+  setEntry(
+    state,
+    source,
+    validCommit(commit, source) ? { status: "syncing", repository: source } : { status: "unavailable", repository: source },
+    generation
+  );
+  return generation;
+}
+function servicesOf(graph, repository) {
+  const services = /* @__PURE__ */ new Set();
+  graph.forEachNode((_id, attrs) => {
+    const node = attrs;
+    if (node.type === import_types7.NodeType.FileNode && node.source === repository && node.service) {
+      services.add(node.service);
+    }
+  });
+  return services;
+}
+function finishSourceExtraction(graph, generation, source, commit, result) {
+  const state = states.get(graph);
+  if (!state) return;
+  state.active.delete(generation);
+  const conflicted = state.conflicted.delete(generation);
+  if (source === void 0 || !REPOSITORY.test(source)) return;
+  const entry = state.repos.get(source);
+  if (!entry || entry.generation !== generation) return;
+  entry.services = servicesOf(graph, source);
+  let shared = false;
+  for (const [name, other] of state.repos) {
+    if (name === source || ![...entry.services].some((s) => other.services.has(s))) continue;
+    shared = true;
+    setEntry(state, name, { status: "unavailable", repository: name }, other.generation);
+  }
+  entry.baseline = !conflicted && !shared && validCommit(commit, source) && result.extractionErrors === 0 && result.skippedFiles === 0 ? { status: "ready", repository: source, sha: commit.sha } : { status: "unavailable", repository: source };
+}
+
 // src/latency-digest.ts
 init_cjs_shims();
 var SUB = 16;
@@ -5282,11 +5368,11 @@ function callSiteFromSpan(span, serviceNode, scanPath) {
   };
 }
 function reconcileObservedRelPath(graph, serviceName, relPath) {
-  if (graph.hasNode((0, import_types7.fileId)(serviceName, relPath))) return relPath;
+  if (graph.hasNode((0, import_types8.fileId)(serviceName, relPath))) return relPath;
   let best = null;
   graph.forEachNode((_id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types7.NodeType.FileNode || a.service !== serviceName) return;
+    if (a.type !== import_types8.NodeType.FileNode || a.service !== serviceName) return;
     if (a.discoveredVia === "otel") return;
     const p = a.path;
     if (!p) return;
@@ -5298,14 +5384,14 @@ function reconcileObservedRelPath(graph, serviceName, relPath) {
 }
 function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
   const svcAttrs = graph.hasNode(serviceNodeId) ? graph.getNodeAttributes(serviceNodeId) : void 0;
-  const canonicalService = svcAttrs && svcAttrs.type === import_types7.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
+  const canonicalService = svcAttrs && svcAttrs.type === import_types8.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
   const relPath = reconcileObservedRelPath(graph, canonicalService, callSite.relPath);
-  const fileNodeId = (0, import_types7.fileId)(canonicalService, relPath);
+  const fileNodeId = (0, import_types8.fileId)(canonicalService, relPath);
   if (!graph.hasNode(fileNodeId)) {
     const language = languageForExt(relPath);
     const node = {
       id: fileNodeId,
-      type: import_types7.NodeType.FileNode,
+      type: import_types8.NodeType.FileNode,
       service: canonicalService,
       path: relPath,
       ...language ? { language } : {},
@@ -5314,14 +5400,14 @@ function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
     };
     graph.addNode(fileNodeId, node);
   }
-  const containsId = makeObservedEdgeId(import_types7.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
+  const containsId = makeObservedEdgeId(import_types8.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
   if (!graph.hasEdge(containsId)) {
     const edge = {
       id: containsId,
       source: serviceNodeId,
       target: fileNodeId,
-      type: import_types7.EdgeType.CONTAINS,
-      provenance: import_types7.Provenance.OBSERVED
+      type: import_types8.EdgeType.CONTAINS,
+      provenance: import_types8.Provenance.OBSERVED
     };
     graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
   }
@@ -5345,11 +5431,11 @@ function pickContainingSymbol(candidates, fn) {
   return [...candidates].sort(bySpan)[0].id;
 }
 function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line) {
-  const sid = (0, import_types7.symbolId)(service, relPath, fn);
+  const sid = (0, import_types8.symbolId)(service, relPath, fn);
   if (!graph.hasNode(sid)) {
     const node = {
       id: sid,
-      type: import_types7.NodeType.SymbolNode,
+      type: import_types8.NodeType.SymbolNode,
       kind: "function",
       qualname: fn,
       span: { startLine: line, endLine: line },
@@ -5359,14 +5445,14 @@ function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line)
     };
     graph.addNode(sid, node);
   }
-  const containsId = makeObservedEdgeId(import_types7.EdgeType.CONTAINS, fileNodeId, sid);
+  const containsId = makeObservedEdgeId(import_types8.EdgeType.CONTAINS, fileNodeId, sid);
   if (!graph.hasEdge(containsId)) {
     const edge = {
       id: containsId,
       source: fileNodeId,
       target: sid,
-      type: import_types7.EdgeType.CONTAINS,
-      provenance: import_types7.Provenance.OBSERVED
+      type: import_types8.EdgeType.CONTAINS,
+      provenance: import_types8.Provenance.OBSERVED
     };
     graph.addEdgeWithKey(containsId, fileNodeId, sid, edge);
   }
@@ -5378,9 +5464,9 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite, mint
   let sawSymbol = false;
   const candidates = [];
   graph.forEachOutboundEdge(fileNodeId, (_edge, edgeAttrs, _source, target) => {
-    if (edgeAttrs.type !== import_types7.EdgeType.CONTAINS) return;
+    if (edgeAttrs.type !== import_types8.EdgeType.CONTAINS) return;
     const t = graph.getNodeAttributes(target);
-    if (t.type !== import_types7.NodeType.SymbolNode) return;
+    if (t.type !== import_types8.NodeType.SymbolNode) return;
     sawSymbol = true;
     if (line >= t.span.startLine && line <= t.span.endLine) {
       candidates.push({ id: target, symbol: t });
@@ -5393,17 +5479,17 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite, mint
   return fileNodeId;
 }
 function makeObservedEdgeId(type, source, target) {
-  return (0, import_types7.observedEdgeId)(source, target, type);
+  return (0, import_types8.observedEdgeId)(source, target, type);
 }
 function makeInferredEdgeId(type, source, target) {
-  return (0, import_types7.inferredEdgeId)(source, target, type);
+  return (0, import_types8.inferredEdgeId)(source, target, type);
 }
 var INFERRED_CONFIDENCE = 0.6;
 var STITCH_MAX_DEPTH = 2;
 var STITCH_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types7.EdgeType.CALLS,
-  import_types7.EdgeType.CONNECTS_TO,
-  import_types7.EdgeType.DEPENDS_ON
+  import_types8.EdgeType.CALLS,
+  import_types8.EdgeType.CONNECTS_TO,
+  import_types8.EdgeType.DEPENDS_ON
 ]);
 var WIRE_SPAN_KIND_CLIENT = 3;
 var WIRE_SPAN_KIND_PRODUCER = 4;
@@ -5419,11 +5505,11 @@ function spanServesGraphqlOperation(kind) {
   return kind !== WIRE_SPAN_KIND_CLIENT && kind !== WIRE_SPAN_KIND_PRODUCER && kind !== WIRE_SPAN_KIND_CONSUMER;
 }
 function ensureGraphqlOperationNode(graph, serviceName, operationType, operationName) {
-  const id = (0, import_types7.graphqlOperationId)(serviceName, operationType, operationName);
+  const id = (0, import_types8.graphqlOperationId)(serviceName, operationType, operationName);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.GraphQLOperationNode,
+    type: import_types8.NodeType.GraphQLOperationNode,
     name: operationName,
     service: serviceName,
     operationType: operationType.toLowerCase(),
@@ -5437,11 +5523,11 @@ function spanServesGrpcMethod(kind) {
   return kind !== WIRE_SPAN_KIND_CLIENT && kind !== WIRE_SPAN_KIND_PRODUCER && kind !== WIRE_SPAN_KIND_CONSUMER;
 }
 function ensureGrpcMethodNode(graph, rpcService, rpcMethod) {
-  const id = (0, import_types7.grpcMethodId)(rpcService, rpcMethod);
+  const id = (0, import_types8.grpcMethodId)(rpcService, rpcMethod);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.GrpcMethodNode,
+    type: import_types8.NodeType.GrpcMethodNode,
     name: `${rpcService}/${rpcMethod}`,
     rpcService,
     rpcMethod,
@@ -5454,11 +5540,11 @@ function spanServesWebsocketChannel(kind) {
   return kind !== WIRE_SPAN_KIND_CLIENT && kind !== WIRE_SPAN_KIND_PRODUCER && kind !== WIRE_SPAN_KIND_CONSUMER;
 }
 function ensureWebsocketChannelNode(graph, serviceName, channel) {
-  const id = (0, import_types7.websocketChannelId)(serviceName, channel);
+  const id = (0, import_types8.websocketChannelId)(serviceName, channel);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.WebSocketChannelNode,
+    type: import_types8.NodeType.WebSocketChannelNode,
     name: channel,
     service: serviceName,
     channel,
@@ -5471,11 +5557,11 @@ function messagingDestinationKind(system) {
   return `${system}-topic`;
 }
 function ensureMessagingDestinationNode(graph, system, destination) {
-  const id = (0, import_types7.infraId)(messagingDestinationKind(system), destination);
+  const id = (0, import_types8.infraId)(messagingDestinationKind(system), destination);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.InfraNode,
+    type: import_types8.NodeType.InfraNode,
     name: destination,
     provider: "self",
     kind: messagingDestinationKind(system)
@@ -5519,9 +5605,9 @@ function lookupParentSpan(traceId, parentSpanId, now) {
   };
 }
 function resolveServiceId(graph, host, env) {
-  const envTagged = (0, import_types7.serviceId)(host, env);
+  const envTagged = (0, import_types8.serviceId)(host, env);
   if (graph.hasNode(envTagged)) return envTagged;
-  const envLess = (0, import_types7.serviceId)(host);
+  const envLess = (0, import_types8.serviceId)(host);
   if (envLess !== envTagged && graph.hasNode(envLess)) return envLess;
   let sameEnv = null;
   let envLessMatch = null;
@@ -5529,7 +5615,7 @@ function resolveServiceId(graph, host, env) {
   graph.forEachNode((id, attrs) => {
     if (sameEnv) return;
     const a = attrs;
-    if (a.type !== import_types7.NodeType.ServiceNode) return;
+    if (a.type !== import_types8.NodeType.ServiceNode) return;
     const matchesByName = a.name === host;
     const matchesByAlias = a.aliases ? a.aliases.includes(host) : false;
     if (!matchesByName && !matchesByAlias) return;
@@ -5544,14 +5630,14 @@ function resolveServiceId(graph, host, env) {
   return sameEnv ?? envLessMatch ?? anyMatch;
 }
 function frontierIdFor(host) {
-  return (0, import_types7.frontierId)(host);
+  return (0, import_types8.frontierId)(host);
 }
 function resolveFusedServiceId(graph, serviceName, env) {
-  const id = (0, import_types7.serviceId)(serviceName, env);
+  const id = (0, import_types8.serviceId)(serviceName, env);
   if (graph.hasNode(id)) return id;
   const wanted = serviceName.toLowerCase();
   const extractedId = graph.findNode((_nid, attrs) => {
-    if (attrs.type !== import_types7.NodeType.ServiceNode) return false;
+    if (attrs.type !== import_types8.NodeType.ServiceNode) return false;
     const svc = attrs;
     if (svc.discoveredVia === "otel") return false;
     return typeof svc.name === "string" && svc.name.toLowerCase() === wanted;
@@ -5563,7 +5649,7 @@ function ensureServiceNode(graph, serviceName, env) {
   if (graph.hasNode(resolved)) return resolved;
   const node = {
     id: resolved,
-    type: import_types7.NodeType.ServiceNode,
+    type: import_types8.NodeType.ServiceNode,
     name: serviceName,
     language: "unknown",
     discoveredVia: "otel",
@@ -5573,11 +5659,11 @@ function ensureServiceNode(graph, serviceName, env) {
   return resolved;
 }
 function ensureInfraNode(graph, kind, name, provider) {
-  const id = (0, import_types7.infraId)(kind, name);
+  const id = (0, import_types8.infraId)(kind, name);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.InfraNode,
+    type: import_types8.NodeType.InfraNode,
     name,
     provider,
     kind
@@ -5589,7 +5675,7 @@ var COLUMN_BEARING_INFRA_KINDS = /* @__PURE__ */ new Set(["sql-table", "supabase
 function mergeColumnsAt(graph, tableNodeId, columns, provenance, confidence) {
   if (!columns || columns.length === 0 || !graph.hasNode(tableNodeId)) return;
   const node = graph.getNodeAttributes(tableNodeId);
-  if (node.type !== import_types7.NodeType.InfraNode || !node.kind || !COLUMN_BEARING_INFRA_KINDS.has(node.kind)) {
+  if (node.type !== import_types8.NodeType.InfraNode || !node.kind || !COLUMN_BEARING_INFRA_KINDS.has(node.kind)) {
     return;
   }
   graph.replaceNodeAttributes(tableNodeId, {
@@ -5598,7 +5684,7 @@ function mergeColumnsAt(graph, tableNodeId, columns, provenance, confidence) {
   });
 }
 function mergeObservedColumns(graph, tableNodeId, columns) {
-  mergeColumnsAt(graph, tableNodeId, columns, import_types7.Provenance.OBSERVED, OBSERVED_COLUMN_CONFIDENCE);
+  mergeColumnsAt(graph, tableNodeId, columns, import_types8.Provenance.OBSERVED, OBSERVED_COLUMN_CONFIDENCE);
 }
 function mergeObservedDeployState(graph, serviceNodeId, state) {
   if (!graph.hasNode(serviceNodeId)) return;
@@ -5609,11 +5695,11 @@ function mergeObservedDeployState(graph, serviceNodeId, state) {
   graph.mergeNodeAttributes(serviceNodeId, attrs);
 }
 function ensureDatabaseNode(graph, host, engine) {
-  const id = (0, import_types7.databaseId)(host);
+  const id = (0, import_types8.databaseId)(host);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.DatabaseNode,
+    type: import_types8.NodeType.DatabaseNode,
     name: host,
     engine,
     engineVersion: "unknown",
@@ -5625,11 +5711,11 @@ function ensureDatabaseNode(graph, host, engine) {
   return id;
 }
 function ensureLocalDatabaseNode(graph, serviceName, name, engine) {
-  const id = (0, import_types7.localDatabaseId)(serviceName, name);
+  const id = (0, import_types8.localDatabaseId)(serviceName, name);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.DatabaseNode,
+    type: import_types8.NodeType.DatabaseNode,
     name,
     engine,
     engineVersion: "unknown",
@@ -5644,17 +5730,17 @@ function findDeclaredDatabaseForService(graph, serviceNodeId, engine) {
   const sources = [serviceNodeId];
   for (const edgeId of graph.outboundEdges(serviceNodeId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === import_types7.EdgeType.CONTAINS) sources.push(e.target);
+    if (e.type === import_types8.EdgeType.CONTAINS) sources.push(e.target);
   }
   const matches = /* @__PURE__ */ new Set();
   for (const src of sources) {
     if (!graph.hasNode(src)) continue;
     for (const edgeId of graph.outboundEdges(src)) {
       const edge = graph.getEdgeAttributes(edgeId);
-      if (edge.type !== import_types7.EdgeType.CONNECTS_TO || edge.provenance !== import_types7.Provenance.EXTRACTED) continue;
+      if (edge.type !== import_types8.EdgeType.CONNECTS_TO || edge.provenance !== import_types8.Provenance.EXTRACTED) continue;
       if (!graph.hasNode(edge.target)) continue;
       const target = graph.getNodeAttributes(edge.target);
-      if (target.type !== import_types7.NodeType.DatabaseNode || target.engine !== engine) continue;
+      if (target.type !== import_types8.NodeType.DatabaseNode || target.engine !== engine) continue;
       matches.add(edge.target);
     }
   }
@@ -5669,7 +5755,7 @@ function ensureFrontierNode(graph, host, ts) {
   }
   const node = {
     id,
-    type: import_types7.NodeType.FrontierNode,
+    type: import_types8.NodeType.FrontierNode,
     name: host,
     host,
     firstObserved: ts,
@@ -5722,11 +5808,11 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     };
     const updated = {
       ...existing,
-      provenance: import_types7.Provenance.OBSERVED,
+      provenance: import_types8.Provenance.OBSERVED,
       lastObserved: ts,
       callCount: newSpanCount,
       signal: newSignal,
-      confidence: (0, import_types7.confidenceForObservedSignal)(newSignal),
+      confidence: (0, import_types8.confidenceForObservedSignal)(newSignal),
       grain
       // backfills legacy edges that predate ADR-142
     };
@@ -5749,8 +5835,8 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     source,
     target,
     type,
-    provenance: import_types7.Provenance.OBSERVED,
-    confidence: (0, import_types7.confidenceForObservedSignal)(signal),
+    provenance: import_types8.Provenance.OBSERVED,
+    confidence: (0, import_types8.confidenceForObservedSignal)(signal),
     lastObserved: ts,
     callCount: 1,
     signal,
@@ -5772,9 +5858,9 @@ function stitchTrace(graph, sourceServiceId, ts) {
     const outbound = graph.outboundEdges(nodeId);
     for (const edgeId of outbound) {
       const edge = graph.getEdgeAttributes(edgeId);
-      if (edge.provenance !== import_types7.Provenance.EXTRACTED) continue;
+      if (edge.provenance !== import_types8.Provenance.EXTRACTED) continue;
       if (!STITCH_EDGE_TYPES.has(edge.type)) continue;
-      if (graph.hasEdge((0, import_types7.observedEdgeId)(edge.source, edge.target, edge.type))) continue;
+      if (graph.hasEdge((0, import_types8.observedEdgeId)(edge.source, edge.target, edge.type))) continue;
       upsertInferredEdge(graph, edge.type, edge.source, edge.target, ts);
       if (!visited.has(edge.target)) {
         visited.add(edge.target);
@@ -5796,7 +5882,7 @@ function upsertInferredEdge(graph, type, source, target, ts) {
     source,
     target,
     type,
-    provenance: import_types7.Provenance.INFERRED,
+    provenance: import_types8.Provenance.INFERRED,
     confidence: INFERRED_CONFIDENCE,
     lastObserved: ts
   };
@@ -5810,7 +5896,7 @@ function emitIncidentEvent(project, ev) {
       incidentId: ev.id,
       affectedNode: ev.affectedNode,
       service: ev.service,
-      incidentKind: (0, import_types7.incidentKindOf)(ev),
+      incidentKind: (0, import_types8.incidentKindOf)(ev),
       at: ev.timestamp
     }
   });
@@ -5839,7 +5925,7 @@ function landIncidentCallSite(span, callSite, trusted, graph) {
   const canonicalService = serviceNodeName(graph, span) ?? span.service;
   const recovered = !trusted;
   if (graph) {
-    const fusedFileId = (0, import_types7.fileId)(canonicalService, relPath);
+    const fusedFileId = (0, import_types8.fileId)(canonicalService, relPath);
     if (graph.hasNode(fusedFileId)) {
       const node = landObservedSymbol(
         graph,
@@ -5859,7 +5945,7 @@ function landIncidentCallSite(span, callSite, trusted, graph) {
     }
     if (recovered) return null;
   }
-  return { affectedNode: (0, import_types7.fileId)(span.service, relPath) };
+  return { affectedNode: (0, import_types8.fileId)(span.service, relPath) };
 }
 function serviceNodeName(graph, span) {
   if (!graph) return void 0;
@@ -5876,7 +5962,7 @@ function stacktraceCallSite(span, serviceNode, scanPath) {
   return { relPath, line: frame.line, ...frame.fn ? { fn: frame.fn } : {} };
 }
 function incidentLocus(span, graph, scanPath) {
-  const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : (0, import_types7.serviceId)(span.service, span.env);
+  const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : (0, import_types8.serviceId)(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
   const callSite = callSiteFromSpan(span, serviceNode, scanPath);
   if (callSite) {
@@ -6059,7 +6145,7 @@ function findRouteNodeByHttpRoute(graph, serviceName, method, httpRoute) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types7.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types8.NodeType.RouteNode || a.service !== serviceName) return;
     if (m && a.method !== "ALL" && a.method !== m) return;
     if (normalizePathTemplate(a.pathTemplate) === target) found = id;
   });
@@ -6092,7 +6178,7 @@ async function handleSpan(ctx, span) {
       let targetId;
       if (host) {
         ensureDatabaseNode(ctx.graph, host, span.dbSystem);
-        targetId = (0, import_types7.databaseId)(host);
+        targetId = (0, import_types8.databaseId)(host);
       } else {
         const declared = findDeclaredDatabaseForService(ctx.graph, sourceId, span.dbSystem);
         if (declared) {
@@ -6109,7 +6195,7 @@ async function handleSpan(ctx, span) {
       }
       const result = upsertObservedEdge(
         ctx.graph,
-        import_types7.EdgeType.CONNECTS_TO,
+        import_types8.EdgeType.CONNECTS_TO,
         observedSource(),
         targetId,
         ts,
@@ -6123,7 +6209,7 @@ async function handleSpan(ctx, span) {
         const collectionId = ensureInfraNode(ctx.graph, "mongodb-collection", span.dbCollection, "self");
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           collectionId,
           ts,
@@ -6137,7 +6223,7 @@ async function handleSpan(ctx, span) {
         const tableId = ensureInfraNode(ctx.graph, "sql-table", span.dbTable, "self");
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           tableId,
           ts,
@@ -6155,7 +6241,7 @@ async function handleSpan(ctx, span) {
       span.messagingSystem,
       span.messagingDestination
     );
-    const edgeType = span.kind === WIRE_SPAN_KIND_CONSUMER ? import_types7.EdgeType.CONSUMES_FROM : import_types7.EdgeType.PUBLISHES_TO;
+    const edgeType = span.kind === WIRE_SPAN_KIND_CONSUMER ? import_types8.EdgeType.CONSUMES_FROM : import_types8.EdgeType.PUBLISHES_TO;
     const result = upsertObservedEdge(
       ctx.graph,
       edgeType,
@@ -6177,7 +6263,7 @@ async function handleSpan(ctx, span) {
     );
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types7.EdgeType.CONTAINS,
+      import_types8.EdgeType.CONTAINS,
       observedSource(),
       targetId,
       ts,
@@ -6191,7 +6277,7 @@ async function handleSpan(ctx, span) {
     const targetId = ensureGrpcMethodNode(ctx.graph, span.rpcService, span.rpcMethod);
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types7.EdgeType.CONTAINS,
+      import_types8.EdgeType.CONTAINS,
       observedSource(),
       targetId,
       ts,
@@ -6209,7 +6295,7 @@ async function handleSpan(ctx, span) {
     );
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types7.EdgeType.CONNECTS_TO,
+      import_types8.EdgeType.CONNECTS_TO,
       observedSource(),
       targetId,
       ts,
@@ -6227,7 +6313,7 @@ async function handleSpan(ctx, span) {
       if (targetId && targetId !== sourceId) {
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           targetId,
           ts,
@@ -6242,7 +6328,7 @@ async function handleSpan(ctx, span) {
         const frontierNodeId = ensureFrontierNode(ctx.graph, host, ts);
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           frontierNodeId,
           ts,
@@ -6270,7 +6356,7 @@ async function handleSpan(ctx, span) {
         } : void 0;
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           fallbackSource,
           sourceId,
           ts,
@@ -6292,7 +6378,7 @@ async function handleSpan(ctx, span) {
     );
     if (routeNodeId) {
       const routeSvc = ctx.graph.getNodeAttributes(routeNodeId).service;
-      upsertObservedEdge(ctx.graph, import_types7.EdgeType.CONTAINS, (0, import_types7.serviceId)(routeSvc), routeNodeId, ts, isError, void 0, durationMs, errorDetail);
+      upsertObservedEdge(ctx.graph, import_types8.EdgeType.CONTAINS, (0, import_types8.serviceId)(routeSvc), routeNodeId, ts, isError, void 0, durationMs, errorDetail);
     }
   }
   if (span.statusCode === 2) {
@@ -6322,7 +6408,7 @@ function promoteFrontierNodes(graph, opts = {}) {
   const aliasIndex = /* @__PURE__ */ new Map();
   graph.forEachNode((id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types7.NodeType.ServiceNode) return;
+    if (a.type !== import_types8.NodeType.ServiceNode) return;
     aliasIndex.set(a.name, id);
     if (a.aliases) {
       for (const alias of a.aliases) aliasIndex.set(alias, id);
@@ -6331,7 +6417,7 @@ function promoteFrontierNodes(graph, opts = {}) {
   const toPromote = [];
   graph.forEachNode((id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types7.NodeType.FrontierNode) return;
+    if (a.type !== import_types8.NodeType.FrontierNode) return;
     const target = aliasIndex.get(a.host);
     if (!target) return;
     if (target === id) return;
@@ -6365,7 +6451,7 @@ function rewireFrontierEdges(graph, frontierId2, serviceId17) {
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
   graph.dropEdge(oldEdgeId);
-  const newId = edge.provenance === import_types7.Provenance.OBSERVED ? (0, import_types7.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types7.Provenance.INFERRED ? (0, import_types7.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types7.extractedEdgeId)(newSource, newTarget, edge.type);
+  const newId = edge.provenance === import_types8.Provenance.OBSERVED ? (0, import_types8.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types8.Provenance.INFERRED ? (0, import_types8.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types8.extractedEdgeId)(newSource, newTarget, edge.type);
   if (graph.hasEdge(newId)) {
     const existing = graph.getEdgeAttributes(newId);
     const merged = {
@@ -6399,12 +6485,12 @@ async function markStaleEdges(graph, options = {}) {
   const project = options.project ?? DEFAULT_PROJECT;
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    if (e.provenance !== import_types7.Provenance.OBSERVED) return;
+    if (e.provenance !== import_types8.Provenance.OBSERVED) return;
     if (!e.lastObserved) return;
     const threshold = thresholdForEdgeType(e.type, thresholds);
     const age = now - new Date(e.lastObserved).getTime();
     if (age > threshold) {
-      const updated = { ...e, provenance: import_types7.Provenance.STALE, confidence: 0.3 };
+      const updated = { ...e, provenance: import_types8.Provenance.STALE, confidence: 0.3 };
       graph.replaceEdgeAttributes(id, updated);
       events.push({
         edgeId: id,
@@ -6421,8 +6507,8 @@ async function markStaleEdges(graph, options = {}) {
         project,
         payload: {
           edgeId: id,
-          from: import_types7.Provenance.OBSERVED,
-          to: import_types7.Provenance.STALE
+          from: import_types8.Provenance.OBSERVED,
+          to: import_types8.Provenance.STALE
         }
       });
     }
@@ -6570,6 +6656,7 @@ function describeZodIssues(error) {
   return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.join(".")}: ${issue.message}` : issue.message).join("; ");
 }
 function mergeSnapshot(graph, snapshot) {
+  invalidateSourceBaseline(graph);
   const exported = snapshot.graph;
   const incomingNodes = Array.isArray(exported.nodes) ? exported.nodes : [];
   const incomingEdges = Array.isArray(exported.edges) ? exported.edges : [];
@@ -6578,7 +6665,7 @@ function mergeSnapshot(graph, snapshot) {
   const validEdges = [];
   for (const node of incomingNodes) {
     if (node.attributes === void 0) continue;
-    const parsed = import_types7.GraphNodeSchema.safeParse(node.attributes);
+    const parsed = import_types8.GraphNodeSchema.safeParse(node.attributes);
     if (!parsed.success) {
       issues.push(`node "${node.key}": ${describeZodIssues(parsed.error)}`);
       continue;
@@ -6587,7 +6674,7 @@ function mergeSnapshot(graph, snapshot) {
   }
   for (const edge of incomingEdges) {
     if (edge.attributes === void 0) continue;
-    const parsed = import_types7.GraphEdgeSchema.safeParse(edge.attributes);
+    const parsed = import_types8.GraphEdgeSchema.safeParse(edge.attributes);
     if (!parsed.success) {
       const label = edge.key ?? `${edge.source}->${edge.target}`;
       issues.push(`edge "${label}": ${describeZodIssues(parsed.error)}`);
@@ -6616,29 +6703,29 @@ function mergeSnapshot(graph, snapshot) {
 }
 
 // src/traverse.ts
-var import_types8 = require("@neat.is/types");
+var import_types9 = require("@neat.is/types");
 var ROOT_CAUSE_MAX_DEPTH = 5;
 var BLAST_RADIUS_DEFAULT_DEPTH = 10;
 function isFrontierNode(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types8.NodeType.FrontierNode;
+  return attrs.type === import_types9.NodeType.FrontierNode;
 }
 function resolveOwningService(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return null;
   const attrs = graph.getNodeAttributes(nodeId);
-  if (attrs.type === import_types8.NodeType.ServiceNode) {
+  if (attrs.type === import_types9.NodeType.ServiceNode) {
     return { id: nodeId, svc: attrs };
   }
-  if (attrs.type === import_types8.NodeType.FileNode || attrs.type === import_types8.NodeType.SymbolNode) {
+  if (attrs.type === import_types9.NodeType.FileNode || attrs.type === import_types9.NodeType.SymbolNode) {
     for (const edgeId of graph.inboundEdges(nodeId)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type !== import_types8.EdgeType.CONTAINS) continue;
+      if (e.type !== import_types9.EdgeType.CONTAINS) continue;
       const owner = graph.getNodeAttributes(e.source);
-      if (owner.type === import_types8.NodeType.ServiceNode) {
+      if (owner.type === import_types9.NodeType.ServiceNode) {
         return { id: e.source, svc: owner };
       }
-      if (owner.type === import_types8.NodeType.FileNode) {
+      if (owner.type === import_types9.NodeType.FileNode) {
         return resolveOwningService(graph, e.source);
       }
     }
@@ -6646,10 +6733,10 @@ function resolveOwningService(graph, nodeId) {
   return null;
 }
 function isFrontierEdge(e) {
-  return e.provenance === import_types8.Provenance.FRONTIER;
+  return e.provenance === import_types9.Provenance.FRONTIER;
 }
 function rankOf(p) {
-  return p === import_types8.Provenance.FRONTIER ? -1 : import_types8.PROV_RANK[p];
+  return p === import_types9.Provenance.FRONTIER ? -1 : import_types9.PROV_RANK[p];
 }
 function bestEdgeBySource(graph, edgeIds) {
   const best = /* @__PURE__ */ new Map();
@@ -6834,10 +6921,10 @@ function symbolRootCauseShape(graph, origin, walk11) {
   return serviceRootCauseShape(graph, owner.svc, walk11);
 }
 var rootCauseShapes = {
-  [import_types8.NodeType.DatabaseNode]: databaseRootCauseShape,
-  [import_types8.NodeType.ServiceNode]: serviceRootCauseShape,
-  [import_types8.NodeType.FileNode]: fileRootCauseShape,
-  [import_types8.NodeType.SymbolNode]: symbolRootCauseShape
+  [import_types9.NodeType.DatabaseNode]: databaseRootCauseShape,
+  [import_types9.NodeType.ServiceNode]: serviceRootCauseShape,
+  [import_types9.NodeType.FileNode]: fileRootCauseShape,
+  [import_types9.NodeType.SymbolNode]: symbolRootCauseShape
 };
 function legacyRootCause(graph, errorNodeId, errorEvent, incidents) {
   if (!graph.hasNode(errorNodeId)) return null;
@@ -6850,7 +6937,7 @@ function legacyRootCause(graph, errorNodeId, errorEvent, incidents) {
       const reason = errorEvent ? `${match.rootCauseReason} (observed error: ${errorEvent.errorMessage})` : match.rootCauseReason;
       return {
         source: "compat",
-        result: import_types8.RootCauseResultSchema.parse({
+        result: import_types9.RootCauseResultSchema.parse({
           rootCauseNode: match.rootCauseNode,
           rootCauseReason: reason,
           traversalPath: walk11.path,
@@ -6861,7 +6948,7 @@ function legacyRootCause(graph, errorNodeId, errorEvent, incidents) {
       };
     }
   }
-  if (origin.type === import_types8.NodeType.ServiceNode) {
+  if (origin.type === import_types9.NodeType.ServiceNode) {
     const crossService = crossServiceRootCause(graph, errorNodeId, incidents, errorEvent);
     if (crossService) return { result: crossService, source: "cross-service" };
   }
@@ -6872,8 +6959,8 @@ var INCIDENT_ROOT_CAUSE_CONFIDENCE = 0.6;
 function incidentMatchesNode(ev, nodeId) {
   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;
+  const sym = (0, import_types9.parseSymbolId)(ev.affectedNode);
+  if (sym && (0, import_types9.fileId)(sym.service, sym.relPath) === nodeId) return true;
   return false;
 }
 function localizeFromIncidents(nodeId, incidents, errorEvent) {
@@ -6906,8 +6993,8 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
   const loc = localizeFromIncidents(nodeId, incidents, errorEvent);
   if (!loc) return null;
   const traversalPath = loc.fileNode ? [nodeId, loc.fileNode] : [nodeId];
-  const edgeProvenances = loc.fileNode ? [import_types8.Provenance.OBSERVED] : [];
-  return import_types8.RootCauseResultSchema.parse({
+  const edgeProvenances = loc.fileNode ? [import_types9.Provenance.OBSERVED] : [];
+  return import_types9.RootCauseResultSchema.parse({
     rootCauseNode: loc.rootCauseNode,
     rootCauseReason: loc.rootCauseReason,
     traversalPath,
@@ -6917,21 +7004,21 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
   });
 }
 function isFailingCallEdge(e) {
-  return e.type === import_types8.EdgeType.CALLS && !isFrontierEdge(e) && (e.signal?.errorCount ?? 0) > 0;
+  return e.type === import_types9.EdgeType.CALLS && !isFrontierEdge(e) && (e.signal?.errorCount ?? 0) > 0;
 }
 function callSourcesForService(graph, serviceId17) {
   const ids = [serviceId17];
   for (const edgeId of graph.outboundEdges(serviceId17)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type !== import_types8.EdgeType.CONTAINS) continue;
+    if (e.type !== import_types9.EdgeType.CONTAINS) continue;
     const tgt = graph.getNodeAttributes(e.target);
-    if (tgt.type !== import_types8.NodeType.FileNode) continue;
+    if (tgt.type !== import_types9.NodeType.FileNode) continue;
     ids.push(e.target);
     for (const symEdgeId of graph.outboundEdges(e.target)) {
       const se = graph.getEdgeAttributes(symEdgeId);
-      if (se.type !== import_types8.EdgeType.CONTAINS) continue;
+      if (se.type !== import_types9.EdgeType.CONTAINS) continue;
       const sym = graph.getNodeAttributes(se.target);
-      if (sym.type === import_types8.NodeType.SymbolNode) ids.push(se.target);
+      if (sym.type === import_types9.NodeType.SymbolNode) ids.push(se.target);
     }
   }
   return ids;
@@ -6978,7 +7065,7 @@ function followFailingCallChain(graph, originServiceId, maxDepth) {
   return { path: path81, edges, culprit: current };
 }
 function isStaleCallEdge(e) {
-  return e.type === import_types8.EdgeType.CALLS && e.provenance === import_types8.Provenance.STALE;
+  return e.type === import_types9.EdgeType.CALLS && e.provenance === import_types9.Provenance.STALE;
 }
 function staleCallDominates(e, id, curEdge, curId) {
   const ev = e.signal?.spanCount ?? e.callCount ?? 0;
@@ -6991,7 +7078,7 @@ function dominantStaleCall(graph, serviceId17, visited) {
   for (const src of callSourcesForService(graph, serviceId17)) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type !== import_types8.EdgeType.CALLS) continue;
+      if (e.type !== import_types9.EdgeType.CALLS) continue;
       if (isFrontierNode(graph, e.target) || isFrontierEdge(e)) continue;
       const owner = resolveOwningService(graph, e.target);
       if (!owner || visited.has(owner.id)) continue;
@@ -7039,10 +7126,10 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
       path81.push(loc.fileNode);
-      edgeProvenances.push(import_types8.Provenance.OBSERVED);
+      edgeProvenances.push(import_types9.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
-    return import_types8.RootCauseResultSchema.parse({
+    return import_types9.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
       traversalPath: path81,
@@ -7054,7 +7141,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   const lastEdge = chain.edges[chain.edges.length - 1];
   const errs = lastEdge.signal?.errorCount ?? 0;
   const culpritName = culprit.replace(/^service:/, "");
-  return import_types8.RootCauseResultSchema.parse({
+  return import_types9.RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
     traversalPath: path81,
@@ -7065,7 +7152,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
 }
 function getBlastRadius(graph, nodeId, maxDepth = BLAST_RADIUS_DEFAULT_DEPTH) {
   if (!graph.hasNode(nodeId)) {
-    return import_types8.BlastRadiusResultSchema.parse({ origin: nodeId, affectedNodes: [], totalAffected: 0 });
+    return import_types9.BlastRadiusResultSchema.parse({ origin: nodeId, affectedNodes: [], totalAffected: 0 });
   }
   const seen = /* @__PURE__ */ new Map();
   const queue = [{ nodeId, distance: 0, path: [nodeId], pathEdges: [] }];
@@ -7098,7 +7185,7 @@ function getBlastRadius(graph, nodeId, maxDepth = BLAST_RADIUS_DEFAULT_DEPTH) {
   const affectedNodes = [...seen.values()].sort(
     (a, b) => a.distance - b.distance || a.nodeId.localeCompare(b.nodeId)
   );
-  return import_types8.BlastRadiusResultSchema.parse({
+  return import_types9.BlastRadiusResultSchema.parse({
     origin: nodeId,
     affectedNodes,
     totalAffected: affectedNodes.length
@@ -7108,7 +7195,7 @@ var TRANSITIVE_DEPENDENCIES_DEFAULT_DEPTH = 3;
 var TRANSITIVE_DEPENDENCIES_MAX_DEPTH = 10;
 function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIES_DEFAULT_DEPTH) {
   if (!graph.hasNode(nodeId)) {
-    return import_types8.TransitiveDependenciesResultSchema.parse({
+    return import_types9.TransitiveDependenciesResultSchema.parse({
       origin: nodeId,
       depth,
       dependencies: [],
@@ -7120,7 +7207,7 @@ function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIE
   const enqueued = /* @__PURE__ */ new Set([nodeId]);
   while (queue.length > 0) {
     const frame = queue.shift();
-    if (frame.distance > 0 && frame.edge && frame.edge.type !== import_types8.EdgeType.CONTAINS) {
+    if (frame.distance > 0 && frame.edge && frame.edge.type !== import_types9.EdgeType.CONTAINS) {
       seen.set(frame.nodeId, {
         nodeId: frame.nodeId,
         distance: frame.distance,
@@ -7139,7 +7226,7 @@ function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIE
   const dependencies = [...seen.values()].sort(
     (a, b) => a.distance - b.distance || a.nodeId.localeCompare(b.nodeId)
   );
-  return import_types8.TransitiveDependenciesResultSchema.parse({
+  return import_types9.TransitiveDependenciesResultSchema.parse({
     origin: nodeId,
     depth,
     dependencies,
@@ -7148,7 +7235,7 @@ function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIE
 }
 function getObservedDependencies(graph, nodeId) {
   if (!graph.hasNode(nodeId)) {
-    return import_types8.ObservedDependenciesResultSchema.parse({
+    return import_types9.ObservedDependenciesResultSchema.parse({
       origin: nodeId,
       dependencies: [],
       observed: false,
@@ -7160,12 +7247,12 @@ function getObservedDependencies(graph, nodeId) {
   }
   const attrs = graph.getNodeAttributes(nodeId);
   const scope = [nodeId];
-  if (attrs.type === import_types8.NodeType.ServiceNode) {
+  if (attrs.type === import_types9.NodeType.ServiceNode) {
     for (const edgeId of graph.outboundEdges(nodeId)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type !== import_types8.EdgeType.CONTAINS) continue;
+      if (e.type !== import_types9.EdgeType.CONTAINS) continue;
       const owned = graph.getNodeAttributes(e.target);
-      if (owned.type === import_types8.NodeType.FileNode) scope.push(e.target);
+      if (owned.type === import_types9.NodeType.FileNode) scope.push(e.target);
     }
   }
   const dependencies = [];
@@ -7174,13 +7261,13 @@ function getObservedDependencies(graph, nodeId) {
   for (const src of scope) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types8.EdgeType.CONTAINS) continue;
-      if (e.provenance === import_types8.Provenance.OBSERVED) {
+      if (e.type === import_types9.EdgeType.CONTAINS) continue;
+      if (e.provenance === import_types9.Provenance.OBSERVED) {
         if (!seenEdge.has(e.id)) {
           seenEdge.add(e.id);
           dependencies.push(e);
         }
-      } else if (e.provenance === import_types8.Provenance.EXTRACTED) {
+      } else if (e.provenance === import_types9.Provenance.EXTRACTED) {
         hasExtractedOutbound = true;
       }
     }
@@ -7191,8 +7278,8 @@ function getObservedDependencies(graph, nodeId) {
   for (const tgt of scope) {
     for (const edgeId of graph.inboundEdges(tgt)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types8.EdgeType.CONTAINS) continue;
-      if (e.provenance === import_types8.Provenance.OBSERVED) {
+      if (e.type === import_types9.EdgeType.CONTAINS) continue;
+      if (e.provenance === import_types9.Provenance.OBSERVED) {
         inboundObservedCount += 1;
         inboundVolume += e.callCount ?? e.signal?.spanCount ?? 1;
         if (e.lastObserved && (!inboundLastObserved || e.lastObserved > inboundLastObserved)) {
@@ -7204,7 +7291,7 @@ function getObservedDependencies(graph, nodeId) {
   dependencies.sort(
     (a, b) => a.target.localeCompare(b.target) || a.source.localeCompare(b.source) || a.id.localeCompare(b.id)
   );
-  return import_types8.ObservedDependenciesResultSchema.parse({
+  return import_types9.ObservedDependenciesResultSchema.parse({
     origin: nodeId,
     dependencies,
     observed: dependencies.length > 0 || inboundObservedCount > 0,
@@ -7221,12 +7308,12 @@ function nodeScope(graph, nodeId) {
   const scope = [nodeId];
   if (!graph.hasNode(nodeId)) return scope;
   const attrs = graph.getNodeAttributes(nodeId);
-  if (attrs.type === import_types8.NodeType.ServiceNode) {
+  if (attrs.type === import_types9.NodeType.ServiceNode) {
     for (const edgeId of graph.outboundEdges(nodeId)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type !== import_types8.EdgeType.CONTAINS) continue;
+      if (e.type !== import_types9.EdgeType.CONTAINS) continue;
       const owned = graph.getNodeAttributes(e.target);
-      if (owned.type === import_types8.NodeType.FileNode) scope.push(e.target);
+      if (owned.type === import_types9.NodeType.FileNode) scope.push(e.target);
     }
   }
   return scope;
@@ -7236,10 +7323,10 @@ function incidentCountForNode(nodeId, incidents) {
   return incidents.filter((ev) => incidentMatchesNode(ev, nodeId)).length;
 }
 var DEP_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types8.EdgeType.CALLS,
-  import_types8.EdgeType.CONNECTS_TO,
-  import_types8.EdgeType.PUBLISHES_TO,
-  import_types8.EdgeType.CONSUMES_FROM
+  import_types9.EdgeType.CALLS,
+  import_types9.EdgeType.CONNECTS_TO,
+  import_types9.EdgeType.PUBLISHES_TO,
+  import_types9.EdgeType.CONSUMES_FROM
 ]);
 var TIMEOUT_ERROR_PATTERNS = [
   /\bDEADLINE_EXCEEDED\b/i,
@@ -7268,11 +7355,11 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
     if (!graph.hasNode(n)) continue;
     for (const edgeId of graph.inboundEdges(n)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types8.EdgeType.CONTAINS) continue;
+      if (e.type === import_types9.EdgeType.CONTAINS) continue;
       if (isFrontierEdge(e)) continue;
       errorsFromCallers += e.signal?.errorCount ?? 0;
       inboundVolume += e.callCount ?? e.signal?.spanCount ?? 0;
-      if (e.provenance === import_types8.Provenance.STALE) stale = true;
+      if (e.provenance === import_types9.Provenance.STALE) stale = true;
       const p95 = e.signal?.latencyMs?.p95;
       if (p95 !== void 0) latencyP95Ms = Math.max(latencyP95Ms ?? 0, p95);
       if (e.lastObserved) {
@@ -7282,11 +7369,11 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
     }
     for (const edgeId of graph.outboundEdges(n)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types8.EdgeType.CONTAINS) continue;
+      if (e.type === import_types9.EdgeType.CONTAINS) continue;
       if (isFrontierEdge(e)) continue;
       outboundVolume += e.callCount ?? e.signal?.spanCount ?? 0;
-      if (e.type === import_types8.EdgeType.CALLS) outboundErrors += e.signal?.errorCount ?? 0;
-      if (e.provenance === import_types8.Provenance.STALE) stale = true;
+      if (e.type === import_types9.EdgeType.CALLS) outboundErrors += e.signal?.errorCount ?? 0;
+      if (e.provenance === import_types9.Provenance.STALE) stale = true;
       if (DEP_EDGE_TYPES.has(e.type)) {
         hasOutboundDeps = true;
         if ((e.signal?.errorCount ?? 0) > 0) observedErroringDownstream = true;
@@ -7367,7 +7454,7 @@ function hasFailingOutbound(graph, nodeId, seedSource, incidents) {
     if (!graph.hasNode(n)) continue;
     for (const edgeId of graph.outboundEdges(n)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types8.EdgeType.CONTAINS) continue;
+      if (e.type === import_types9.EdgeType.CONTAINS) continue;
       if ((e.signal?.errorCount ?? 0) > 0) return true;
     }
   }
@@ -7381,9 +7468,9 @@ function hasFailingOutbound(graph, nodeId, seedSource, incidents) {
 function grainOf(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return "unknown";
   const t = graph.getNodeAttributes(nodeId).type;
-  if (t === import_types8.NodeType.ServiceNode) return "service";
-  if (t === import_types8.NodeType.FileNode) return "file";
-  if (t === import_types8.NodeType.SymbolNode) return "symbol";
+  if (t === import_types9.NodeType.ServiceNode) return "service";
+  if (t === import_types9.NodeType.FileNode) return "file";
+  if (t === import_types9.NodeType.SymbolNode) return "symbol";
   return t;
 }
 function findPath(graph, from, to, direction, maxDepth) {
@@ -7419,7 +7506,7 @@ var EMPTY_CONTEXT = {
 };
 function expandNode(graph, nodeId, direction, incidents, now = Date.now()) {
   if (!graph.hasNode(nodeId)) {
-    return import_types8.ExpandResultSchema.parse({
+    return import_types9.ExpandResultSchema.parse({
       origin: nodeId,
       direction,
       node: { id: nodeId, classification: "unrelated", context: EMPTY_CONTEXT },
@@ -7430,7 +7517,7 @@ function expandNode(graph, nodeId, direction, incidents, now = Date.now()) {
   const best = direction === "up" ? bestEdgeBySource(graph, graph.inboundEdges(nodeId)) : bestEdgeByTarget(graph, graph.outboundEdges(nodeId));
   const neighbours = [];
   for (const [nid, edge] of best) {
-    if (edge.type === import_types8.EdgeType.CONTAINS) continue;
+    if (edge.type === import_types9.EdgeType.CONTAINS) continue;
     const nctx = nodeContext(graph, nid, incidents, now);
     neighbours.push({
       node: nid,
@@ -7441,7 +7528,7 @@ function expandNode(graph, nodeId, direction, incidents, now = Date.now()) {
     });
   }
   neighbours.sort((a, b) => a.node.localeCompare(b.node));
-  return import_types8.ExpandResultSchema.parse({
+  return import_types9.ExpandResultSchema.parse({
     origin: nodeId,
     direction,
     node: { id: nodeId, classification: classifyNode(ctx), context: ctx },
@@ -7461,7 +7548,7 @@ function relate(graph, a, b, maxDepth = ROOT_CAUSE_MAX_DEPTH) {
     )
   });
   if (!graph.hasNode(a) || !graph.hasNode(b)) {
-    return import_types8.RelateResultSchema.parse({
+    return import_types9.RelateResultSchema.parse({
       a,
       b,
       related: false,
@@ -7473,7 +7560,7 @@ function relate(graph, a, b, maxDepth = ROOT_CAUSE_MAX_DEPTH) {
   const down = findPath(graph, a, b, "down", maxDepth);
   const up = findPath(graph, a, b, "up", maxDepth);
   if (!down && !up) {
-    return import_types8.RelateResultSchema.parse({
+    return import_types9.RelateResultSchema.parse({
       a,
       b,
       related: false,
@@ -7488,7 +7575,7 @@ function relate(graph, a, b, maxDepth = ROOT_CAUSE_MAX_DEPTH) {
   if (up) paths.push(buildPath(up));
   const endpointsFine = grainOf(graph, a) !== "service" && grainOf(graph, b) !== "service";
   const grainGap = endpointsFine && paths[0].grain.some((g) => g === "service");
-  return import_types8.RelateResultSchema.parse({
+  return import_types9.RelateResultSchema.parse({
     a,
     b,
     related: true,
@@ -7548,7 +7635,7 @@ function declaredOutboundCallees(graph, nodeId) {
     for (const edgeId of graph.outboundEdges(n)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (!DEP_EDGE_TYPES.has(e.type)) continue;
-      if (e.provenance !== import_types8.Provenance.EXTRACTED) continue;
+      if (e.provenance !== import_types9.Provenance.EXTRACTED) continue;
       if (e.target === nodeId || byTarget.has(e.target)) continue;
       const route = e.evidence?.pathTemplate;
       byTarget.set(
@@ -7581,7 +7668,7 @@ function observedOutboundNextServices(graph, nodeId) {
     for (const edgeId of graph.outboundEdges(n)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (!DEP_EDGE_TYPES.has(e.type)) continue;
-      if (e.provenance !== import_types8.Provenance.OBSERVED) continue;
+      if (e.provenance !== import_types9.Provenance.OBSERVED) continue;
       if (e.target !== nodeId) targets.add(e.target);
     }
   }
@@ -7603,7 +7690,7 @@ function resolveHangHop(graph, boundaryNode, incidents) {
 function stagedHangProposal(graph, boundaryNode, incidents) {
   const hop = resolveHangHop(graph, boundaryNode, incidents);
   if (!hop) return null;
-  if (!graph.hasEdge((0, import_types8.frontierEdgeId)(hop.source, hop.target, import_types8.EdgeType.CALLS))) return null;
+  if (!graph.hasEdge((0, import_types9.frontierEdgeId)(hop.source, hop.target, import_types9.EdgeType.CALLS))) return null;
   return hop.route !== void 0 ? { node: hop.target, route: hop.route } : { node: hop.target };
 }
 function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
@@ -7628,7 +7715,7 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
         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: loadOriginConfidence(origin.ctx, seedCtx),
-        provenance: import_types8.Provenance.OBSERVED
+        provenance: import_types9.Provenance.OBSERVED
       });
     }
     candidates.push({
@@ -7647,7 +7734,7 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
       reason: `${name} is unreachable: its callers' requests fail (${seedCtx.errorsFromCallers} erroring inbound calls) and it produced no telemetry of its own \u2014 no server spans, no outbound calls \u2014 so it never served. The failure is observed, but its cause is not in the trace: a startup failure, a crash before the first span, or an unschedulable / unhealthy pod. Inspect ${name}'s deploy state and logs \u2014 there is no code fault to find in the graph here.`,
       context: seedCtx,
       confidence: legacy.confidence,
-      provenance: import_types8.Provenance.OBSERVED
+      provenance: import_types9.Provenance.OBSERVED
     });
   } else if (seedCtx && isBoundaryTimeoutSymptom(seedCtx)) {
     const seedName = displayNameOf(seedNode);
@@ -7669,7 +7756,7 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
         reason: `${causeName} is the proposed hang cause (FRONTIER \u2014 a hypothesis, not observed): the boundary ${seedName} only timed out waiting and the culprit hung without exporting a span, so NEAT staged a FRONTIER surface on the unobservable hop${routeNote}. It graduates to OBSERVED when ${causeName} comes back; until then, inspect it / restore instrumentation to confirm, or it is culled.`,
         context: nodeContext(graph, proposal.node, incidents, now),
         confidence: Math.min(legacy.confidence, PROVENANCE_CEILING.FRONTIER),
-        provenance: import_types8.Provenance.FRONTIER
+        provenance: import_types9.Provenance.FRONTIER
       });
     }
   } else if (staleChain) {
@@ -7683,7 +7770,7 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
       reason: `${culpritName} is the stale-derived root cause (low confidence): live telemetry for this subgraph has gone quiet, but the last-observed topology traces the failure surfacing at ${seedName} downstream through a STALE call chain to ${culpritName}. Provenance is STALE, so confidence is capped low \u2014 restore instrumentation and re-run to confirm before acting.`,
       context: nodeContext(graph, culprit, incidents, now),
       confidence: staleConfidence,
-      provenance: import_types8.Provenance.STALE
+      provenance: import_types9.Provenance.STALE
     });
     candidates.push({
       node: seedNode,
@@ -7716,11 +7803,11 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
       edgeProvenances = path81.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
-      edgeProvenances = [top.provenance ?? import_types8.Provenance.OBSERVED];
+      edgeProvenances = [top.provenance ?? import_types9.Provenance.OBSERVED];
     }
   }
   const fixRecommendation = fixRecommendationForTop(top, seedNode, legacy);
-  return import_types8.RootCauseResultSchema.parse({
+  return import_types9.RootCauseResultSchema.parse({
     rootCauseNode: top.node,
     rootCauseReason: top.reason,
     traversalPath,
@@ -7738,7 +7825,7 @@ function fixRecommendationForTop(top, seedNode, legacy) {
   if (top.classification === "symptom-only" && top.context.boundaryTimeout === true) {
     return `${name} timed out waiting on a downstream that hung and exported no span \u2014 the cause is unobservable from traces. Inspect the FRONTIER surface NEAT staged on the unobservable hop (see candidates); it graduates to OBSERVED when that service recovers. Restore instrumentation on that path to confirm, rather than treating ${name} as the fault.`;
   }
-  if (top.provenance === import_types8.Provenance.STALE) {
+  if (top.provenance === import_types9.Provenance.STALE) {
     return `Live telemetry for this path has gone quiet; the last-observed topology traces the failure downstream to ${name}. Restore instrumentation (or re-run with live traces) to confirm, then inspect ${name}.`;
   }
   if (top.classification === "primary-failure") {
@@ -7752,34 +7839,34 @@ function bucketKey(source, target, type) {
   return `${type}|${source}|${target}`;
 }
 function bucketSourceFor(graph, edge) {
-  if (edge.type !== import_types9.EdgeType.CONNECTS_TO) return edge.source;
-  const parsed = (0, import_types9.parseFileId)(edge.source);
+  if (edge.type !== import_types10.EdgeType.CONNECTS_TO) return edge.source;
+  const parsed = (0, import_types10.parseFileId)(edge.source);
   if (!parsed || !graph.hasNode(edge.target)) return edge.source;
   const target = graph.getNodeAttributes(edge.target);
-  if (target.type !== import_types9.NodeType.DatabaseNode) return edge.source;
-  return (0, import_types9.serviceId)(parsed.service);
+  if (target.type !== import_types10.NodeType.DatabaseNode) return edge.source;
+  return (0, import_types10.serviceId)(parsed.service);
 }
 function bucketEdges(graph) {
   const buckets2 = /* @__PURE__ */ new Map();
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    const parsed = (0, import_types9.parseEdgeId)(id);
+    const parsed = (0, import_types10.parseEdgeId)(id);
     const provenance = parsed?.provenance ?? e.provenance;
     const source = bucketSourceFor(graph, e);
     const key = bucketKey(source, e.target, e.type);
     const cur = buckets2.get(key) ?? { source, target: e.target, type: e.type };
     switch (provenance) {
-      case import_types9.Provenance.EXTRACTED:
+      case import_types10.Provenance.EXTRACTED:
         cur.extracted = e;
         break;
-      case import_types9.Provenance.OBSERVED:
+      case import_types10.Provenance.OBSERVED:
         cur.observed = e;
         break;
-      case import_types9.Provenance.INFERRED:
+      case import_types10.Provenance.INFERRED:
         cur.inferred = e;
         break;
       default:
-        if (e.provenance === import_types9.Provenance.STALE) cur.stale = e;
+        if (e.provenance === import_types10.Provenance.STALE) cur.stale = e;
     }
     buckets2.set(key, cur);
   });
@@ -7788,22 +7875,22 @@ function bucketEdges(graph) {
 function nodeIsFrontier(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types9.NodeType.FrontierNode;
+  return attrs.type === import_types10.NodeType.FrontierNode;
 }
 function nodeIsWebsocketChannel(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types9.NodeType.WebSocketChannelNode;
+  return attrs.type === import_types10.NodeType.WebSocketChannelNode;
 }
 function nodeIsServerAction(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types9.NodeType.ServerActionNode;
+  return attrs.type === import_types10.NodeType.ServerActionNode;
 }
 function nodeIsSymbol(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types9.NodeType.SymbolNode;
+  return attrs.type === import_types10.NodeType.SymbolNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -7823,14 +7910,14 @@ function gradedConfidence(edge) {
   return clampConfidence(confidenceForEdge(edge));
 }
 var OBSERVABLE_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types9.EdgeType.CALLS,
-  import_types9.EdgeType.CONNECTS_TO,
-  import_types9.EdgeType.PUBLISHES_TO,
-  import_types9.EdgeType.CONSUMES_FROM
+  import_types10.EdgeType.CALLS,
+  import_types10.EdgeType.CONNECTS_TO,
+  import_types10.EdgeType.PUBLISHES_TO,
+  import_types10.EdgeType.CONSUMES_FROM
 ]);
 function detectMissingDivergences(graph, bucket) {
   const out = [];
-  if (bucket.type === import_types9.EdgeType.CONTAINS) return out;
+  if (bucket.type === import_types10.EdgeType.CONTAINS) return out;
   if (nodeIsSymbol(graph, bucket.source) || nodeIsSymbol(graph, bucket.target)) return out;
   if (bucket.extracted && !bucket.observed && OBSERVABLE_EDGE_TYPES.has(bucket.type)) {
     if (!nodeIsFrontier(graph, bucket.target) && !nodeIsServerAction(graph, bucket.target)) {
@@ -7872,7 +7959,7 @@ function declaredHostFor(svc) {
 function hasExtractedConfiguredBy(graph, svcId) {
   for (const edgeId of graph.outboundEdges(svcId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === import_types9.EdgeType.CONFIGURED_BY && e.provenance === import_types9.Provenance.EXTRACTED) {
+    if (e.type === import_types10.EdgeType.CONFIGURED_BY && e.provenance === import_types10.Provenance.EXTRACTED) {
       return true;
     }
   }
@@ -7885,10 +7972,10 @@ function detectHostMismatch(graph, svcId, svc) {
   const out = [];
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types9.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types9.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types10.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types10.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types9.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types10.NodeType.DatabaseNode) continue;
     const observedHost = target.host?.trim();
     if (!observedHost) continue;
     if (observedHost === declaredHost) continue;
@@ -7910,10 +7997,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 !== import_types9.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types9.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types10.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types10.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types9.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types10.NodeType.DatabaseNode) continue;
     for (const pair of compatPairs()) {
       if (pair.engine !== target.engine) continue;
       const declared = deps[pair.driver];
@@ -8076,11 +8163,11 @@ function symbolLocus(graph, ev) {
   const location = filepath ? `${filepath}${lineno !== void 0 ? `:${lineno}` : ""}` : void 0;
   const affected = ev.affectedNode;
   const affectedInGraph = affected.length > 0 && graph.hasNode(affected);
-  const affectedIsCode = affectedInGraph && ((0, import_types9.parseSymbolId)(affected) !== null || (0, import_types9.parseFileId)(affected) !== null);
+  const affectedIsCode = affectedInGraph && ((0, import_types10.parseSymbolId)(affected) !== null || (0, import_types10.parseFileId)(affected) !== null);
   if (affectedIsCode) return { node: affected, ...location ? { location } : {} };
   if (!location) return null;
   if (affectedInGraph) return { node: affected, location };
-  const svc = (0, import_types9.serviceId)(ev.service);
+  const svc = (0, import_types10.serviceId)(ev.service);
   if (graph.hasNode(svc)) return { node: svc, location };
   return null;
 }
@@ -8123,7 +8210,7 @@ function detectSymbolMismatches(graph, incidents) {
       mismatchKind: g.kind,
       ...g.symbol ? { symbol: g.symbol } : {},
       ...g.location ? { location: g.location } : {},
-      provenance: import_types9.Provenance.INFERRED,
+      provenance: import_types10.Provenance.INFERRED,
       incidentId: g.latest.id,
       errorMessage: g.latest.errorMessage,
       incidentCount: g.count,
@@ -8140,7 +8227,7 @@ var OBSERVED_FAILING_CONFIDENCE = 0.6;
 function detectObservedFailingEdge(graph, bucket) {
   if (!bucket.extracted || !bucket.observed) return [];
   if (!OBSERVABLE_EDGE_TYPES.has(bucket.type)) return [];
-  if (bucket.observed.provenance !== import_types9.Provenance.OBSERVED) return [];
+  if (bucket.observed.provenance !== import_types10.Provenance.OBSERVED) return [];
   const signal = bucket.observed.signal;
   if (!signal) return [];
   const { spanCount, errorCount } = signal;
@@ -8154,7 +8241,7 @@ function detectObservedFailingEdge(graph, bucket) {
       source: bucket.source,
       target: bucket.target,
       failureKind: "error-rate",
-      provenance: import_types9.Provenance.INFERRED,
+      provenance: import_types10.Provenance.INFERRED,
       edgeType: bucket.type,
       observed: bucket.observed,
       spanCount,
@@ -8259,7 +8346,7 @@ function detectObservedFailingIncidents(graph, incidents) {
       source: g.node,
       target: g.node,
       failureKind: g.kind,
-      provenance: import_types9.Provenance.INFERRED,
+      provenance: import_types10.Provenance.INFERRED,
       ...g.location ? { location: g.location } : {},
       incidentId: g.latest.id,
       errorMessage: g.latest.errorMessage,
@@ -8278,24 +8365,24 @@ function involvesNode(d, nodeId) {
 function datastoreEverObserved(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const n = graph.getNodeAttributes(nodeId);
-  if (n.type === import_types9.NodeType.DatabaseNode) {
+  if (n.type === import_types10.NodeType.DatabaseNode) {
     const via = n.discoveredVia;
     if (via === "otel" || via === "merged") return true;
   }
   for (const edgeId of graph.inboundEdges(nodeId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.provenance === import_types9.Provenance.OBSERVED || e.provenance === import_types9.Provenance.STALE) return true;
+    if (e.provenance === import_types10.Provenance.OBSERVED || e.provenance === import_types10.Provenance.STALE) return true;
   }
   return false;
 }
 function serviceHasObservedSameEngineStore(graph, buckets2, serviceId17, engine, excludeTarget) {
   for (const bucket of buckets2.values()) {
-    if (bucket.type !== import_types9.EdgeType.CONNECTS_TO) continue;
+    if (bucket.type !== import_types10.EdgeType.CONNECTS_TO) continue;
     if (bucket.source !== serviceId17) continue;
     if (bucket.target === excludeTarget) continue;
     if (!graph.hasNode(bucket.target)) continue;
     const target = graph.getNodeAttributes(bucket.target);
-    if (target.type !== import_types9.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types10.NodeType.DatabaseNode) continue;
     if (target.engine !== engine) continue;
     if (bucket.observed || datastoreEverObserved(graph, bucket.target)) return true;
   }
@@ -8305,10 +8392,10 @@ var DEAD_CODE_PROBE_CONFIDENCE = 0.1;
 function dampenDeadCodeProbes(graph, buckets2, all) {
   return all.map((d) => {
     if (d.type !== "missing-observed") return d;
-    if (!d.extracted || d.edgeType !== import_types9.EdgeType.CONNECTS_TO) return d;
+    if (!d.extracted || d.edgeType !== import_types10.EdgeType.CONNECTS_TO) return d;
     if (!graph.hasNode(d.target)) return d;
     const target = graph.getNodeAttributes(d.target);
-    if (target.type !== import_types9.NodeType.DatabaseNode) return d;
+    if (target.type !== import_types10.NodeType.DatabaseNode) return d;
     if (d.extracted.evidence?.hostSource !== "literal") return d;
     if (datastoreEverObserved(graph, d.target)) return d;
     const engine = target.engine;
@@ -8328,7 +8415,7 @@ function suppressHostMismatchHalves(all) {
   for (const d of all) {
     if (d.type !== "host-mismatch") continue;
     observedHalf.add(`${d.source}->${d.target}`);
-    declaredHalf.add((0, import_types9.databaseId)(d.extractedHost));
+    declaredHalf.add((0, import_types10.databaseId)(d.extractedHost));
   }
   if (observedHalf.size === 0) return all;
   return all.filter((d) => {
@@ -8348,14 +8435,14 @@ function computeDivergences(graph, opts = {}) {
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
-    if (n.type === import_types9.NodeType.ServiceNode) {
+    if (n.type === import_types10.NodeType.ServiceNode) {
       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);
       for (const d of detectDeployDivergence(svc)) all.push(d);
       return;
     }
-    if (n.type === import_types9.NodeType.InfraNode && n.kind === "sql-table") {
+    if (n.type === import_types10.NodeType.InfraNode && n.kind === "sql-table") {
       for (const d of detectColumnDrift(n)) all.push(d);
     }
   });
@@ -8420,7 +8507,7 @@ function computeDivergences(graph, opts = {}) {
     const bloc = "location" in b && b.location ? b.location : "";
     return aloc.localeCompare(bloc);
   });
-  return import_types9.DivergenceResultSchema.parse({
+  return import_types10.DivergenceResultSchema.parse({
     divergences: filtered,
     totalAffected: filtered.length,
     computedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -8484,7 +8571,7 @@ var import_node_fs22 = require("fs");
 var import_node_path24 = __toESM(require("path"), 1);
 var import_ignore2 = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
-var import_types19 = require("@neat.is/types");
+var import_types20 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
@@ -8557,7 +8644,7 @@ function pythonToPackage(service) {
 init_cjs_shims();
 var import_node_fs13 = require("fs");
 var import_node_path14 = __toESM(require("path"), 1);
-var import_types10 = require("@neat.is/types");
+var import_types11 = require("@neat.is/types");
 function parseGoMod(source) {
   const module2 = source.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
   if (!module2) return null;
@@ -8593,8 +8680,8 @@ async function discoverGoService(scanPath, dir) {
   const pkg = { name, dependencies: mod.dependencies };
   const framework = goFramework(mod.dependencies);
   const node = {
-    id: (0, import_types10.serviceId)(name),
-    type: import_types10.NodeType.ServiceNode,
+    id: (0, import_types11.serviceId)(name),
+    type: import_types11.NodeType.ServiceNode,
     name,
     language: "go",
     dependencies: mod.dependencies,
@@ -8608,7 +8695,7 @@ async function discoverGoService(scanPath, dir) {
 init_cjs_shims();
 var import_node_fs14 = require("fs");
 var import_node_path15 = __toESM(require("path"), 1);
-var import_types11 = require("@neat.is/types");
+var import_types12 = require("@neat.is/types");
 function parseGemfile(source) {
   const dependencies = {};
   for (const raw of source.split(/\r?\n/)) {
@@ -8632,8 +8719,8 @@ async function discoverRubyService(scanPath, dir) {
   const name = import_node_path15.default.basename(dir);
   const pkg = { name, dependencies: gemfile.dependencies };
   const node = {
-    id: (0, import_types11.serviceId)(name),
-    type: import_types11.NodeType.ServiceNode,
+    id: (0, import_types12.serviceId)(name),
+    type: import_types12.NodeType.ServiceNode,
     name,
     language: "ruby",
     dependencies: gemfile.dependencies,
@@ -8646,7 +8733,7 @@ async function discoverRubyService(scanPath, dir) {
 // src/extract/php.ts
 init_cjs_shims();
 var import_node_path16 = __toESM(require("path"), 1);
-var import_types12 = require("@neat.is/types");
+var import_types13 = require("@neat.is/types");
 function parseComposerJson(composer) {
   return {
     dependencies: {
@@ -8666,8 +8753,8 @@ async function discoverPhpService(scanPath, dir) {
   const name = import_node_path16.default.basename(dir);
   const pkg = { name, dependencies };
   const node = {
-    id: (0, import_types12.serviceId)(name),
-    type: import_types12.NodeType.ServiceNode,
+    id: (0, import_types13.serviceId)(name),
+    type: import_types13.NodeType.ServiceNode,
     name,
     language: "php",
     dependencies,
@@ -8681,7 +8768,7 @@ async function discoverPhpService(scanPath, dir) {
 init_cjs_shims();
 var import_node_fs15 = require("fs");
 var import_node_path17 = __toESM(require("path"), 1);
-var import_types13 = require("@neat.is/types");
+var import_types14 = require("@neat.is/types");
 var CSHARP_PROJECT_EXTS = /* @__PURE__ */ new Set([".csproj", ".sln"]);
 async function projectFiles(dir) {
   const entries = await import_node_fs15.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
@@ -8728,8 +8815,8 @@ async function discoverCsharpService(scanPath, dir) {
   }
   const pkg = { name, dependencies };
   const node = {
-    id: (0, import_types13.serviceId)(name),
-    type: import_types13.NodeType.ServiceNode,
+    id: (0, import_types14.serviceId)(name),
+    type: import_types14.NodeType.ServiceNode,
     name,
     language: "csharp",
     dependencies,
@@ -8744,7 +8831,7 @@ async function discoverCsharpService(scanPath, dir) {
 init_cjs_shims();
 var import_node_fs16 = require("fs");
 var import_node_path18 = __toESM(require("path"), 1);
-var import_types14 = require("@neat.is/types");
+var import_types15 = require("@neat.is/types");
 var JAVA_MANIFESTS = ["pom.xml", "build.gradle", "build.gradle.kts"];
 async function hasJavaManifest(dir) {
   for (const manifest of JAVA_MANIFESTS) {
@@ -8799,8 +8886,8 @@ async function discoverJavaService(scanPath, dir) {
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
-    id: (0, import_types14.serviceId)(name),
-    type: import_types14.NodeType.ServiceNode,
+    id: (0, import_types15.serviceId)(name),
+    type: import_types15.NodeType.ServiceNode,
     name,
     language: "java",
     dependencies,
@@ -8813,7 +8900,7 @@ async function discoverJavaService(scanPath, dir) {
 init_cjs_shims();
 var import_node_fs17 = require("fs");
 var import_node_path19 = __toESM(require("path"), 1);
-var import_types15 = require("@neat.is/types");
+var import_types16 = require("@neat.is/types");
 var KOTLIN_SOURCE_EXT = ".kt";
 var JAVA_SOURCE_EXT = ".java";
 var SOURCE_PROBE_MAX_DEPTH = 8;
@@ -8864,8 +8951,8 @@ async function discoverKotlinService(scanPath, dir) {
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
-    id: (0, import_types15.serviceId)(name),
-    type: import_types15.NodeType.ServiceNode,
+    id: (0, import_types16.serviceId)(name),
+    type: import_types16.NodeType.ServiceNode,
     name,
     language: "kotlin",
     dependencies,
@@ -8879,7 +8966,7 @@ init_cjs_shims();
 var import_node_fs18 = require("fs");
 var import_node_path20 = __toESM(require("path"), 1);
 var import_smol_toml2 = require("smol-toml");
-var import_types16 = require("@neat.is/types");
+var import_types17 = require("@neat.is/types");
 var CARGO_MANIFEST = "Cargo.toml";
 async function hasRustManifest(dir) {
   return exists2(import_node_path20.default.join(dir, CARGO_MANIFEST));
@@ -8914,8 +9001,8 @@ async function discoverRustService(scanPath, dir) {
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
-    id: (0, import_types16.serviceId)(name),
-    type: import_types16.NodeType.ServiceNode,
+    id: (0, import_types17.serviceId)(name),
+    type: import_types17.NodeType.ServiceNode,
     name,
     language: "rust",
     dependencies,
@@ -8928,7 +9015,7 @@ async function discoverRustService(scanPath, dir) {
 init_cjs_shims();
 var import_node_fs19 = require("fs");
 var import_node_path21 = __toESM(require("path"), 1);
-var import_types17 = require("@neat.is/types");
+var import_types18 = require("@neat.is/types");
 var CMAKE_MANIFEST = "CMakeLists.txt";
 async function hasCppManifest(dir) {
   return exists2(import_node_path21.default.join(dir, CMAKE_MANIFEST));
@@ -8946,8 +9033,8 @@ async function discoverCppService(scanPath, dir) {
   const dependencies = {};
   const pkg = { name, dependencies };
   const node = {
-    id: (0, import_types17.serviceId)(name),
-    type: import_types17.NodeType.ServiceNode,
+    id: (0, import_types18.serviceId)(name),
+    type: import_types18.NodeType.ServiceNode,
     name,
     language: "cpp",
     dependencies,
@@ -8960,7 +9047,7 @@ async function discoverCppService(scanPath, dir) {
 init_cjs_shims();
 var import_node_fs20 = require("fs");
 var import_node_path22 = __toESM(require("path"), 1);
-var import_types18 = require("@neat.is/types");
+var import_types19 = require("@neat.is/types");
 function languageForSourceExt(ext) {
   switch (ext) {
     case ".py":
@@ -9046,8 +9133,8 @@ async function discoverDockerfileService(scanPath, dir) {
   const name = import_node_path22.default.basename(dir);
   const pkg = { name, dependencies: {} };
   const node = {
-    id: (0, import_types18.serviceId)(name),
-    type: import_types18.NodeType.ServiceNode,
+    id: (0, import_types19.serviceId)(name),
+    type: import_types19.NodeType.ServiceNode,
     name,
     language,
     dependencies: {},
@@ -9241,8 +9328,8 @@ async function discoverNodeService(scanPath, dir) {
   const framework = detectJsFramework(pkg);
   const language = await detectJsServiceLanguage(dir, pkg);
   const node = {
-    id: (0, import_types19.serviceId)(pkg.name),
-    type: import_types19.NodeType.ServiceNode,
+    id: (0, import_types20.serviceId)(pkg.name),
+    type: import_types20.NodeType.ServiceNode,
     name: pkg.name,
     language,
     version: pkg.version,
@@ -9258,8 +9345,8 @@ async function discoverPyService(scanPath, dir) {
   if (!py) return null;
   const pkg = pythonToPackage(py);
   const node = {
-    id: (0, import_types19.serviceId)(py.name),
-    type: import_types19.NodeType.ServiceNode,
+    id: (0, import_types20.serviceId)(py.name),
+    type: import_types20.NodeType.ServiceNode,
     name: py.name,
     language: "python",
     version: py.version,
@@ -9378,7 +9465,7 @@ init_cjs_shims();
 var import_node_path25 = __toESM(require("path"), 1);
 var import_node_fs23 = require("fs");
 var import_yaml2 = require("yaml");
-var import_types20 = require("@neat.is/types");
+var import_types21 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
   "Service",
   "Deployment",
@@ -9388,7 +9475,7 @@ var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
 function addAliases(graph, serviceId17, candidates) {
   if (!graph.hasNode(serviceId17)) return;
   const node = graph.getNodeAttributes(serviceId17);
-  if (node.type !== import_types20.NodeType.ServiceNode) return;
+  if (node.type !== import_types21.NodeType.ServiceNode) return;
   const set = new Set(node.aliases ?? []);
   for (const c of candidates) {
     if (!c) continue;
@@ -9578,7 +9665,7 @@ var import_tree_sitter_java = __toESM(require("tree-sitter-java"), 1);
 var import_tree_sitter_kotlin = __toESM(require("tree-sitter-kotlin"), 1);
 var import_tree_sitter_rust2 = __toESM(require("tree-sitter-rust"), 1);
 var import_tree_sitter_cpp = __toESM(require("tree-sitter-cpp"), 1);
-var import_types21 = require("@neat.is/types");
+var import_types22 = require("@neat.is/types");
 var PARSE_CHUNK3 = 16384;
 var GRAMMAR_BY_EXT = {
   ".ts": import_tree_sitter_typescript.default.typescript,
@@ -9631,7 +9718,9 @@ function collectSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const visit = (node, classCtx) => {
@@ -9690,7 +9779,9 @@ function collectPythonSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const visit = (node, classCtx) => {
@@ -9763,7 +9854,9 @@ function collectGoSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const visit = (node) => {
@@ -9797,7 +9890,9 @@ function collectRubySymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const nameText = (node) => node.childForFieldName("name")?.text.replace(/::/g, ".");
@@ -9848,7 +9943,9 @@ function collectPhpSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const dot = (s) => s.replace(/\\/g, ".").replace(/::/g, ".").replace(/^\.+/, "");
@@ -9914,7 +10011,9 @@ function collectCsharpSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
@@ -9976,7 +10075,9 @@ function collectJavaSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
@@ -10033,7 +10134,9 @@ function collectKotlinSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
@@ -10103,7 +10206,9 @@ function collectRustSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const join = (prefix, name) => prefix ? `${prefix}::${name}` : name;
@@ -10171,7 +10276,9 @@ function collectCppSymbolDefs(root) {
       kind,
       qualname,
       startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
+      endLine: node.endPosition.row + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
     });
   };
   const join = (prefix, name) => prefix ? `${prefix}::${name}` : name;
@@ -10299,6 +10406,22 @@ function disambiguate(defs) {
     return { def, disambiguator: ordinal };
   });
 }
+function utf8Offsets(content, defs) {
+  if (content.includes("\uFFFD")) return /* @__PURE__ */ new Map();
+  const indices = [...new Set(defs.flatMap(({ startIndex, endIndex }) => [startIndex, endIndex]))].sort(
+    (a, b) => a - b
+  );
+  const offsets = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  let bytes = 0;
+  for (const index of indices) {
+    if (index < cursor || index > content.length) return /* @__PURE__ */ new Map();
+    bytes += Buffer.byteLength(content.slice(cursor, index), "utf8");
+    offsets.set(index, bytes);
+    cursor = index;
+  }
+  return offsets;
+}
 async function addSymbols(graph, services) {
   const parsers = /* @__PURE__ */ new Map();
   const parserForExt5 = (ext) => {
@@ -10322,47 +10445,59 @@ async function addSymbols(graph, services) {
       if (!parser) continue;
       const relPath = toPosix(import_node_path27.default.relative(service.dir, file.path));
       let defs;
+      let completeParse;
       try {
         const tree = parseSource3(parser, file.content);
         defs = collectSymbolDefsForExt(ext, tree.rootNode);
+        completeParse = !tree.rootNode.hasError;
       } catch (err) {
         recordExtractionError("symbol extraction", file.path, err);
         continue;
       }
       if (defs.length === 0) continue;
-      const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
-        graph,
-        service.pkg.name,
-        service.node.id,
-        relPath
-      );
+      const offsets = completeParse ? utf8Offsets(file.content, defs) : /* @__PURE__ */ new Map();
+      const {
+        fileNodeId,
+        nodesAdded: fn,
+        edgesAdded: fe
+      } = ensureFileNode(graph, service.pkg.name, service.node.id, relPath);
       nodesAdded += fn;
       edgesAdded += fe;
       for (const { def, disambiguator } of disambiguate(defs)) {
-        const sid = (0, import_types21.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
+        const sid = (0, import_types22.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
+        const startByte = offsets.get(def.startIndex);
+        const endByte = offsets.get(def.endIndex);
+        const precise = startByte !== void 0 && endByte !== void 0 && endByte > startByte ? { startByte, endByte } : {};
+        const node = {
+          id: sid,
+          type: import_types22.NodeType.SymbolNode,
+          kind: def.kind,
+          qualname: def.qualname,
+          span: { startLine: def.startLine, endLine: def.endLine, ...precise },
+          service: service.pkg.name,
+          relPath,
+          discoveredVia: "static"
+        };
         if (!graph.hasNode(sid)) {
-          const node = {
-            id: sid,
-            type: import_types21.NodeType.SymbolNode,
-            kind: def.kind,
-            qualname: def.qualname,
-            span: { startLine: def.startLine, endLine: def.endLine },
-            service: service.pkg.name,
-            relPath,
-            discoveredVia: "static"
-          };
           graph.addNode(sid, node);
           nodesAdded++;
+        } else {
+          const previous = graph.getNodeAttributes(sid);
+          const discoveredVia = previous.discoveredVia === "otel" || previous.discoveredVia === "merged" ? "merged" : "static";
+          const moved = previous.span.startLine !== node.span.startLine || previous.span.endLine !== node.span.endLine || previous.span.startByte !== node.span.startByte || previous.span.endByte !== node.span.endByte;
+          if (moved || previous.kind !== node.kind || previous.qualname !== node.qualname || previous.discoveredVia !== discoveredVia || previous.service !== node.service || previous.relPath !== node.relPath) {
+            graph.replaceNodeAttributes(sid, { ...previous, ...node, discoveredVia });
+          }
         }
-        const containsId = (0, import_types21.extractedEdgeId)(fileNodeId, sid, import_types21.EdgeType.CONTAINS);
+        const containsId = (0, import_types22.extractedEdgeId)(fileNodeId, sid, import_types22.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: fileNodeId,
             target: sid,
-            type: import_types21.EdgeType.CONTAINS,
-            provenance: import_types21.Provenance.EXTRACTED,
-            confidence: (0, import_types21.confidenceForExtracted)("structural"),
+            type: import_types22.EdgeType.CONTAINS,
+            provenance: import_types22.Provenance.EXTRACTED,
+            confidence: (0, import_types22.confidenceForExtracted)("structural"),
             evidence: {
               file: relPath,
               line: def.startLine,
@@ -10382,7 +10517,7 @@ async function addSymbols(graph, services) {
 init_cjs_shims();
 var import_node_path28 = __toESM(require("path"), 1);
 var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
-var import_types22 = require("@neat.is/types");
+var import_types23 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
   for (let i = 0; i < classHeritage.namedChildCount; i++) {
     const child = classHeritage.namedChild(i);
@@ -10500,7 +10635,7 @@ async function addSymbolEdges(graph, services) {
       }
       const disambiguated = disambiguate(collectSymbolDefs(root));
       const locals = disambiguated.map(({ def, disambiguator }) => ({
-        sid: (0, import_types22.symbolId)(serviceName, relPath, def.qualname, disambiguator),
+        sid: (0, import_types23.symbolId)(serviceName, relPath, def.qualname, disambiguator),
         qualname: def.qualname,
         kind: def.kind,
         startLine: def.startLine,
@@ -10529,10 +10664,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_types22.symbolId)(serviceName, imp.targetRelPath, imp.importedName);
+          const candidate = (0, import_types23.symbolId)(serviceName, imp.targetRelPath, imp.importedName);
           if (graph.hasNode(candidate)) {
             const node = graph.getNodeAttributes(candidate);
-            if (node.type === import_types22.NodeType.SymbolNode && node.kind === wantKind) return candidate;
+            if (node.type === import_types23.NodeType.SymbolNode && node.kind === wantKind) return candidate;
           }
         }
         return null;
@@ -10559,7 +10694,7 @@ async function addSymbolEdges(graph, services) {
                   sourceSid: self.sid,
                   targetName: ext.name,
                   wantKind: "class",
-                  edgeType: import_types22.EdgeType.INHERITS,
+                  edgeType: import_types23.EdgeType.INHERITS,
                   line: ext.line
                 });
               }
@@ -10568,7 +10703,7 @@ async function addSymbolEdges(graph, services) {
                   sourceSid: self.sid,
                   targetName: impl.name,
                   wantKind: "class",
-                  edgeType: import_types22.EdgeType.IMPLEMENTS,
+                  edgeType: import_types23.EdgeType.IMPLEMENTS,
                   line: impl.line
                 });
               }
@@ -10584,7 +10719,7 @@ async function addSymbolEdges(graph, services) {
                 sourceSid: caller.sid,
                 targetName: fn.text,
                 wantKind: "function",
-                edgeType: import_types22.EdgeType.CALLS,
+                edgeType: import_types23.EdgeType.CALLS,
                 line
               });
             }
@@ -10600,15 +10735,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_types22.extractedEdgeId)(req.sourceSid, targetSid, req.edgeType);
+        const edgeId = (0, import_types23.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_types22.Provenance.EXTRACTED,
-          confidence: (0, import_types22.confidenceForExtracted)("structural"),
+          provenance: import_types23.Provenance.EXTRACTED,
+          confidence: (0, import_types23.confidenceForExtracted)("structural"),
           evidence: {
             file: relPath,
             line: req.line,
@@ -10627,7 +10762,7 @@ async function addSymbolEdges(graph, services) {
 init_cjs_shims();
 var import_node_path29 = __toESM(require("path"), 1);
 var import_tree_sitter5 = __toESM(require("tree-sitter"), 1);
-var import_types23 = require("@neat.is/types");
+var import_types24 = require("@neat.is/types");
 function stringLiteralText2(node) {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
@@ -10797,11 +10932,11 @@ async function addServerActions(graph, services) {
       nodesAdded += fn;
       edgesAdded += fe;
       for (const action of actions) {
-        const aid = (0, import_types23.serverActionId)(service.pkg.name, relPath, action.exportName);
+        const aid = (0, import_types24.serverActionId)(service.pkg.name, relPath, action.exportName);
         if (!graph.hasNode(aid)) {
           const node = {
             id: aid,
-            type: import_types23.NodeType.ServerActionNode,
+            type: import_types24.NodeType.ServerActionNode,
             name: action.exportName,
             service: service.pkg.name,
             module: relPath,
@@ -10813,15 +10948,15 @@ async function addServerActions(graph, services) {
           graph.addNode(aid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types23.extractedEdgeId)(fileNodeId, aid, import_types23.EdgeType.CONTAINS);
+        const containsId = (0, import_types24.extractedEdgeId)(fileNodeId, aid, import_types24.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: fileNodeId,
             target: aid,
-            type: import_types23.EdgeType.CONTAINS,
-            provenance: import_types23.Provenance.EXTRACTED,
-            confidence: (0, import_types23.confidenceForExtracted)("structural"),
+            type: import_types24.EdgeType.CONTAINS,
+            provenance: import_types24.Provenance.EXTRACTED,
+            confidence: (0, import_types24.confidenceForExtracted)("structural"),
             evidence: {
               file: relPath,
               line: action.line,
@@ -10851,7 +10986,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_types23.serverActionId)(service.pkg.name, target, binding.importedName);
+        const aid = (0, import_types24.serverActionId)(service.pkg.name, target, binding.importedName);
         if (graph.hasNode(aid)) actionBindings.set(local, aid);
       }
       if (actionBindings.size === 0) continue;
@@ -10866,15 +11001,15 @@ async function addServerActions(graph, services) {
           nodesAdded += ensured.nodesAdded;
           edgesAdded += ensured.edgesAdded;
         }
-        const callsId = (0, import_types23.extractedEdgeId)(clientFileId, aid, import_types23.EdgeType.CALLS);
+        const callsId = (0, import_types24.extractedEdgeId)(clientFileId, aid, import_types24.EdgeType.CALLS);
         if (graph.hasEdge(callsId)) continue;
         const edge = {
           id: callsId,
           source: clientFileId,
           target: aid,
-          type: import_types23.EdgeType.CALLS,
-          provenance: import_types23.Provenance.EXTRACTED,
-          confidence: (0, import_types23.confidenceForExtracted)("structural"),
+          type: import_types24.EdgeType.CALLS,
+          provenance: import_types24.Provenance.EXTRACTED,
+          confidence: (0, import_types24.confidenceForExtracted)("structural"),
           evidence: {
             file: relPath,
             line,
@@ -10892,7 +11027,7 @@ async function addServerActions(graph, services) {
 // src/extract/databases/index.ts
 init_cjs_shims();
 var import_node_path38 = __toESM(require("path"), 1);
-var import_types24 = require("@neat.is/types");
+var import_types25 = require("@neat.is/types");
 
 // src/extract/databases/db-config-yaml.ts
 init_cjs_shims();
@@ -11551,8 +11686,8 @@ function compatibleDriversFor(engine) {
 }
 function toDatabaseNode(config) {
   return {
-    id: (0, import_types24.databaseId)(config.host),
-    type: import_types24.NodeType.DatabaseNode,
+    id: (0, import_types25.databaseId)(config.host),
+    type: import_types25.NodeType.DatabaseNode,
     name: config.database || config.host,
     engine: config.engine,
     engineVersion: config.engineVersion,
@@ -11693,12 +11828,12 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       edgesAdded += fe;
       const evidenceFile = toPosix(import_node_path38.default.relative(scanPath, config.sourceFile));
       const edge = {
-        id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types24.EdgeType.CONNECTS_TO),
+        id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types25.EdgeType.CONNECTS_TO),
         source: fileNodeId,
         target: dbNode.id,
-        type: import_types24.EdgeType.CONNECTS_TO,
-        provenance: import_types24.Provenance.EXTRACTED,
-        confidence: (0, import_types24.confidenceForExtracted)("structural"),
+        type: import_types25.EdgeType.CONNECTS_TO,
+        provenance: import_types25.Provenance.EXTRACTED,
+        confidence: (0, import_types25.confidenceForExtracted)("structural"),
         // Carry how the host was recovered (ADR-213) so the divergence ranker
         // can tell a real declared store from a hardcoded fault-injection /
         // flag-gated probe. Only set when the parser distinguished the two.
@@ -11713,11 +11848,11 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       const primary = allConfigs[0];
       service.node.dbConnectionTarget = primary.port ? `${primary.host}:${primary.port}` : primary.host;
       const relPath = import_node_path38.default.relative(scanPath, primary.sourceFile);
-      const cfgId = (0, import_types24.configId)(relPath);
+      const cfgId = (0, import_types25.configId)(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
-          type: import_types24.NodeType.ConfigNode,
+          type: import_types25.NodeType.ConfigNode,
           name: import_node_path38.default.basename(primary.sourceFile),
           path: relPath,
           fileType: isConfigFile(import_node_path38.default.basename(primary.sourceFile)).fileType || "config"
@@ -11726,12 +11861,12 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
         nodesAdded++;
       }
       const cfgEdge = {
-        id: (0, import_types3.extractedEdgeId)(service.node.id, cfgId, import_types24.EdgeType.CONFIGURED_BY),
+        id: (0, import_types3.extractedEdgeId)(service.node.id, cfgId, import_types25.EdgeType.CONFIGURED_BY),
         source: service.node.id,
         target: cfgId,
-        type: import_types24.EdgeType.CONFIGURED_BY,
-        provenance: import_types24.Provenance.EXTRACTED,
-        confidence: (0, import_types24.confidenceForExtracted)("structural"),
+        type: import_types25.EdgeType.CONFIGURED_BY,
+        provenance: import_types25.Provenance.EXTRACTED,
+        confidence: (0, import_types25.confidenceForExtracted)("structural"),
         evidence: { file: toPosix(relPath) }
       };
       if (!graph.hasEdge(cfgEdge.id)) {
@@ -11763,7 +11898,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 init_cjs_shims();
 var import_node_fs27 = require("fs");
 var import_node_path39 = __toESM(require("path"), 1);
-var import_types25 = require("@neat.is/types");
+var import_types26 = require("@neat.is/types");
 async function walkConfigFiles(dir, excludeDirs = []) {
   const excluded = new Set(excludeDirs.map((d) => import_node_path39.default.resolve(d)));
   const out = [];
@@ -11792,8 +11927,8 @@ async function addConfigNodes(graph, services, scanPath) {
     for (const file of configFiles) {
       const relPath = import_node_path39.default.relative(scanPath, file);
       const node = {
-        id: (0, import_types25.configId)(relPath),
-        type: import_types25.NodeType.ConfigNode,
+        id: (0, import_types26.configId)(relPath),
+        type: import_types26.NodeType.ConfigNode,
         name: import_node_path39.default.basename(file),
         path: relPath,
         fileType: isConfigFile(import_node_path39.default.basename(file)).fileType
@@ -11812,12 +11947,12 @@ async function addConfigNodes(graph, services, scanPath) {
       nodesAdded += fn;
       edgesAdded += fe;
       const edge = {
-        id: (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types25.EdgeType.CONFIGURED_BY),
+        id: (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types26.EdgeType.CONFIGURED_BY),
         source: fileNodeId,
         target: node.id,
-        type: import_types25.EdgeType.CONFIGURED_BY,
-        provenance: import_types25.Provenance.EXTRACTED,
-        confidence: (0, import_types25.confidenceForExtracted)("structural"),
+        type: import_types26.EdgeType.CONFIGURED_BY,
+        provenance: import_types26.Provenance.EXTRACTED,
+        confidence: (0, import_types26.confidenceForExtracted)("structural"),
         evidence: { file: relPath.split(import_node_path39.default.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
@@ -11833,7 +11968,7 @@ async function addConfigNodes(graph, services, scanPath) {
 init_cjs_shims();
 var import_node_fs28 = require("fs");
 var import_node_path40 = __toESM(require("path"), 1);
-var import_types26 = require("@neat.is/types");
+var import_types27 = 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);
@@ -11913,11 +12048,11 @@ async function addGrpcMethods(graph, services) {
       }
       if (methods.length === 0) continue;
       for (const method of methods) {
-        const mid = (0, import_types26.grpcMethodId)(method.rpcService, method.rpcMethod);
+        const mid = (0, import_types27.grpcMethodId)(method.rpcService, method.rpcMethod);
         if (!graph.hasNode(mid)) {
           const node = {
             id: mid,
-            type: import_types26.NodeType.GrpcMethodNode,
+            type: import_types27.NodeType.GrpcMethodNode,
             name: `${method.rpcService}/${method.rpcMethod}`,
             rpcService: method.rpcService,
             rpcMethod: method.rpcMethod,
@@ -11928,15 +12063,15 @@ async function addGrpcMethods(graph, services) {
           graph.addNode(mid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types26.extractedEdgeId)(service.node.id, mid, import_types26.EdgeType.CONTAINS);
+        const containsId = (0, import_types27.extractedEdgeId)(service.node.id, mid, import_types27.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: service.node.id,
             target: mid,
-            type: import_types26.EdgeType.CONTAINS,
-            provenance: import_types26.Provenance.EXTRACTED,
-            confidence: (0, import_types26.confidenceForExtracted)("structural"),
+            type: import_types27.EdgeType.CONTAINS,
+            provenance: import_types27.Provenance.EXTRACTED,
+            confidence: (0, import_types27.confidenceForExtracted)("structural"),
             evidence: {
               file: relFile,
               line: method.line,
@@ -11954,7 +12089,7 @@ async function addGrpcMethods(graph, services) {
 
 // src/extract/calls/index.ts
 init_cjs_shims();
-var import_types46 = require("@neat.is/types");
+var import_types47 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
@@ -11963,7 +12098,7 @@ var import_tree_sitter6 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript4 = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_typescript2 = __toESM(require("tree-sitter-typescript"), 1);
 var import_tree_sitter_python4 = __toESM(require("tree-sitter-python"), 1);
-var import_types27 = require("@neat.is/types");
+var import_types28 = 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) {
@@ -12057,7 +12192,7 @@ async function addHttpCallEdges(graph, services) {
         const dedupKey = `${relFile}|${targetId}`;
         if (seen.has(dedupKey)) continue;
         seen.add(dedupKey);
-        const confidence = (0, import_types27.confidenceForExtracted)("url-literal-service-target");
+        const confidence = (0, import_types28.confidenceForExtracted)("url-literal-service-target");
         const ev = {
           file: relFile,
           line: site.line,
@@ -12071,25 +12206,25 @@ async function addHttpCallEdges(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        if (!(0, import_types27.passesExtractedFloor)(confidence)) {
+        if (!(0, import_types28.passesExtractedFloor)(confidence)) {
           noteExtractedDropped({
             source: fileNodeId,
             target: targetId,
-            type: import_types27.EdgeType.CALLS,
+            type: import_types28.EdgeType.CALLS,
             confidence,
             confidenceKind: "url-literal-service-target",
             evidence: ev
           });
           continue;
         }
-        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, targetId, import_types27.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, targetId, import_types28.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: targetId,
-            type: import_types27.EdgeType.CALLS,
-            provenance: import_types27.Provenance.EXTRACTED,
+            type: import_types28.EdgeType.CALLS,
+            provenance: import_types28.Provenance.EXTRACTED,
             confidence,
             evidence: ev
           };
@@ -12107,7 +12242,7 @@ init_cjs_shims();
 var import_node_path42 = __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_types28 = require("@neat.is/types");
+var import_types29 = require("@neat.is/types");
 var PARSE_CHUNK5 = 16384;
 function parseSource5(parser, source) {
   return parser.parse(
@@ -12351,9 +12486,9 @@ function buildRouteIndex(graph) {
   const index = /* @__PURE__ */ new Map();
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types28.NodeType.RouteNode) return;
+    if (node.type !== import_types29.NodeType.RouteNode) return;
     const route = attrs;
-    const owner = (0, import_types28.serviceId)(route.service);
+    const owner = (0, import_types29.serviceId)(route.service);
     const entry = {
       method: route.method.toUpperCase(),
       normalizedPath: normalizePathTemplate(route.pathTemplate),
@@ -12408,8 +12543,8 @@ async function addRouteCallEdges(graph, services) {
           noteExtractedDropped({
             source: fileNodeId2,
             target: "route:unresolved",
-            type: import_types28.EdgeType.CALLS,
-            confidence: (0, import_types28.confidenceForExtracted)("reconstructed-approximate"),
+            type: import_types29.EdgeType.CALLS,
+            confidence: (0, import_types29.confidenceForExtracted)("reconstructed-approximate"),
             confidenceKind: "reconstructed-approximate",
             evidence: {
               file: relFile,
@@ -12442,7 +12577,7 @@ async function addRouteCallEdges(graph, services) {
         edgesAdded += e;
         const anchored = pathHasLiteralAnchor(site.pathTemplate);
         const confidenceKind = site.approximate && !anchored ? "reconstructed-approximate" : "verified-call-site";
-        const confidence = (0, import_types28.confidenceForExtracted)(confidenceKind);
+        const confidence = (0, import_types29.confidenceForExtracted)(confidenceKind);
         const ev = {
           file: relFile,
           line: site.line,
@@ -12451,25 +12586,25 @@ async function addRouteCallEdges(graph, services) {
           pathTemplate: site.pathTemplate,
           ...confidenceKind === "reconstructed-approximate" ? { approximate: true, reason: site.reason } : {}
         };
-        if (!(0, import_types28.passesExtractedFloor)(confidence)) {
+        if (!(0, import_types29.passesExtractedFloor)(confidence)) {
           noteExtractedDropped({
             source: fileNodeId,
             target: match.routeNodeId,
-            type: import_types28.EdgeType.CALLS,
+            type: import_types29.EdgeType.CALLS,
             confidence,
             confidenceKind,
             evidence: ev
           });
           continue;
         }
-        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, match.routeNodeId, import_types28.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, match.routeNodeId, import_types29.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: match.routeNodeId,
-            type: import_types28.EdgeType.CALLS,
-            provenance: import_types28.Provenance.EXTRACTED,
+            type: import_types29.EdgeType.CALLS,
+            provenance: import_types29.Provenance.EXTRACTED,
             confidence,
             evidence: ev
           };
@@ -12485,7 +12620,7 @@ async function addRouteCallEdges(graph, services) {
 // src/extract/calls/kafka.ts
 init_cjs_shims();
 var import_node_path43 = __toESM(require("path"), 1);
-var import_types29 = require("@neat.is/types");
+var import_types30 = 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;
 var SARAMA_IMPORT_RE = /"[^"]*\/sarama"/;
@@ -12562,7 +12697,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = anchor !== void 0 ? file.content.slice(0, anchor).split("\n").length : lineOf(file.content, topic);
     out.push({
-      infraId: (0, import_types29.infraId)("kafka-topic", topic),
+      infraId: (0, import_types30.infraId)("kafka-topic", topic),
       name: topic,
       kind: "kafka-topic",
       edgeType,
@@ -12590,7 +12725,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/redis.ts
 init_cjs_shims();
 var import_node_path44 = __toESM(require("path"), 1);
-var import_types30 = require("@neat.is/types");
+var import_types31 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
   const out = [];
@@ -12603,7 +12738,7 @@ function redisEndpointsFromFile(file, serviceDir) {
     seen.add(host);
     const line = lineOf(file.content, host);
     out.push({
-      infraId: (0, import_types30.infraId)("redis", host),
+      infraId: (0, import_types31.infraId)("redis", host),
       name: host,
       kind: "redis",
       edgeType: "CALLS",
@@ -12624,7 +12759,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/aws.ts
 init_cjs_shims();
 var import_node_path45 = __toESM(require("path"), 1);
-var import_types31 = require("@neat.is/types");
+var import_types32 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
 function hasMarker(text, markers) {
@@ -12648,7 +12783,7 @@ function awsEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, name);
     out.push({
-      infraId: (0, import_types31.infraId)(kind, name),
+      infraId: (0, import_types32.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -12683,7 +12818,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/grpc.ts
 init_cjs_shims();
 var import_node_path46 = __toESM(require("path"), 1);
-var import_types32 = require("@neat.is/types");
+var import_types33 = 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['"`]/;
@@ -12732,7 +12867,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
     const { kind } = classified;
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types32.infraId)(kind, name),
+      infraId: (0, import_types33.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -12753,7 +12888,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/supabase.ts
 init_cjs_shims();
 var import_node_path47 = __toESM(require("path"), 1);
-var import_types33 = require("@neat.is/types");
+var import_types34 = 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;
@@ -12801,7 +12936,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
     seen.add(name);
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types33.infraId)("supabase", name),
+      infraId: (0, import_types34.infraId)("supabase", name),
       name,
       kind: "supabase",
       edgeType: "CALLS",
@@ -12832,7 +12967,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
       seen.add(key);
       const line = lineOf(file.content, am[0]);
       out.push({
-        infraId: (0, import_types33.infraId)(kind, resource),
+        infraId: (0, import_types34.infraId)(kind, resource),
         name: resource,
         kind,
         edgeType: "CALLS",
@@ -12853,7 +12988,7 @@ init_cjs_shims();
 var import_node_path48 = __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_types34 = require("@neat.is/types");
+var import_types35 = 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) {
@@ -13117,7 +13252,7 @@ function firestoreEndpointsFromFile(file, serviceDir, imported) {
       }
     }
     out.push({
-      infraId: (0, import_types34.infraId)("firestore-collection", collPath),
+      infraId: (0, import_types35.infraId)("firestore-collection", collPath),
       name: collPath,
       kind: "firestore-collection",
       edgeType: "CALLS",
@@ -13233,7 +13368,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
 // src/extract/calls/mongoose.ts
 init_cjs_shims();
 var import_node_path49 = __toESM(require("path"), 1);
-var import_types35 = require("@neat.is/types");
+var import_types36 = 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*\)/;
@@ -13378,7 +13513,7 @@ function collectModelDefs(content, pluralizeOn) {
 function endpoint(r, file, serviceDir, matchText) {
   const line = lineOf(file.content, matchText);
   return {
-    infraId: (0, import_types35.infraId)(r.kind, r.name),
+    infraId: (0, import_types36.infraId)(r.kind, r.name),
     name: r.name,
     kind: r.kind,
     edgeType: "CALLS",
@@ -13531,7 +13666,7 @@ init_cjs_shims();
 var import_node_path50 = __toESM(require("path"), 1);
 var import_tree_sitter9 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_python5 = __toESM(require("tree-sitter-python"), 1);
-var import_types36 = require("@neat.is/types");
+var import_types37 = require("@neat.is/types");
 var SQLALCHEMY_IMPORT_RE = /(?:from|import)\s+(?:flask_sqlalchemy|sqlalchemy)\b/;
 var PARSE_CHUNK6 = 16384;
 function makePyParser3() {
@@ -13685,7 +13820,7 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
     if (seen.has(name)) return;
     seen.add(name);
     out.push({
-      infraId: (0, import_types36.infraId)("sql-table", name),
+      infraId: (0, import_types37.infraId)("sql-table", name),
       name,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -13793,7 +13928,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
       if (seen.has(key)) continue;
       seen.add(key);
       out.push({
-        infraId: (0, import_types36.infraId)("sql-table", t),
+        infraId: (0, import_types37.infraId)("sql-table", t),
         name: t,
         kind: "sql-table",
         edgeType: "CALLS",
@@ -13814,7 +13949,7 @@ init_cjs_shims();
 var import_node_path51 = __toESM(require("path"), 1);
 var import_tree_sitter10 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_python6 = __toESM(require("tree-sitter-python"), 1);
-var import_types37 = require("@neat.is/types");
+var import_types38 = require("@neat.is/types");
 var SOCKET_IMPORT_RE = /(?:^|\n)\s*(?:import\s+socket\b|from\s+socket\s+import\b)/;
 var PARSE_CHUNK7 = 16384;
 function makePyParser4() {
@@ -13880,7 +14015,7 @@ function socketEndpointsFromFile(file, serviceDir) {
     seen.add(name);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types37.infraId)("socket", name),
+      infraId: (0, import_types38.infraId)("socket", name),
       name,
       kind: "socket",
       edgeType: "CALLS",
@@ -13901,7 +14036,7 @@ init_cjs_shims();
 var import_node_path52 = __toESM(require("path"), 1);
 var import_tree_sitter11 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_python7 = __toESM(require("tree-sitter-python"), 1);
-var import_types38 = require("@neat.is/types");
+var import_types39 = require("@neat.is/types");
 var DJANGO_IMPORT_RE = /(?:from|import)\s+django\b/;
 var PARSE_CHUNK8 = 16384;
 function makePyParser5() {
@@ -13981,7 +14116,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types38.infraId)("sql-table", table),
+      infraId: (0, import_types39.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -13997,7 +14132,7 @@ init_cjs_shims();
 var import_node_path53 = __toESM(require("path"), 1);
 var import_tree_sitter12 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript7 = __toESM(require("tree-sitter-javascript"), 1);
-var import_types39 = require("@neat.is/types");
+var import_types40 = require("@neat.is/types");
 var DRIZZLE_IMPORT_RE = /drizzle-orm/;
 var TABLE_BUILDERS = /* @__PURE__ */ new Set(["pgTable", "mysqlTable", "sqliteTable"]);
 function parserForExt3(ext) {
@@ -14088,7 +14223,7 @@ function drizzleEndpointsFromFile(file, serviceDir) {
           const columns = columnsFromObject(obj);
           const line = node.startPosition.row + 1;
           out.push({
-            infraId: (0, import_types39.infraId)("sql-table", tableName),
+            infraId: (0, import_types40.infraId)("sql-table", tableName),
             name: tableName,
             kind: "sql-table",
             edgeType: "CALLS",
@@ -14198,7 +14333,7 @@ function drizzleForeignKeys(file, serviceDir) {
 // src/extract/calls/prisma.ts
 init_cjs_shims();
 var import_node_path54 = __toESM(require("path"), 1);
-var import_types40 = require("@neat.is/types");
+var import_types41 = require("@neat.is/types");
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
   "String",
@@ -14246,7 +14381,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
     if (seenTable.has(b.tableName)) return;
     seenTable.add(b.tableName);
     out.push({
-      infraId: (0, import_types40.infraId)("sql-table", b.tableName),
+      infraId: (0, import_types41.infraId)("sql-table", b.tableName),
       name: b.tableName,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -14418,7 +14553,7 @@ init_cjs_shims();
 var import_node_path55 = __toESM(require("path"), 1);
 var import_tree_sitter13 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_ruby3 = __toESM(require("tree-sitter-ruby"), 1);
-var import_types41 = require("@neat.is/types");
+var import_types42 = require("@neat.is/types");
 var AR_SCHEMA_RE = /ActiveRecord::Schema/;
 var PARSE_CHUNK9 = 16384;
 function makeRubyParser2() {
@@ -14616,7 +14751,7 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
     if (!table || seen.has(table.name)) return;
     seen.add(table.name);
     out.push({
-      infraId: (0, import_types41.infraId)("sql-table", table.name),
+      infraId: (0, import_types42.infraId)("sql-table", table.name),
       name: table.name,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -14722,7 +14857,7 @@ function railsModelEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types41.infraId)("sql-table", table),
+      infraId: (0, import_types42.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -14780,7 +14915,7 @@ init_cjs_shims();
 var import_node_path56 = __toESM(require("path"), 1);
 var import_tree_sitter14 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_php3 = __toESM(require("tree-sitter-php"), 1);
-var import_types42 = require("@neat.is/types");
+var import_types43 = require("@neat.is/types");
 var LARAVEL_SCHEMA_RE = /\bSchema::(create|createIfNotExists|table)\b/;
 var PARSE_CHUNK10 = 16384;
 function makePhpParser2() {
@@ -15027,7 +15162,7 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       }
     }
     out.push({
-      infraId: (0, import_types42.infraId)("sql-table", bp.table),
+      infraId: (0, import_types43.infraId)("sql-table", bp.table),
       name: bp.table,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -15170,7 +15305,7 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
     seen.add(table);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types42.infraId)("sql-table", table),
+      infraId: (0, import_types43.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -15227,7 +15362,7 @@ init_cjs_shims();
 var import_node_path59 = __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_types43 = require("@neat.is/types");
+var import_types44 = require("@neat.is/types");
 init_otel();
 var PARSE_CHUNK11 = 16384;
 var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
@@ -15321,7 +15456,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
     const columns = columnsFromSqlStatement(sql);
     const line = node.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types43.infraId)("sql-table", table),
+      infraId: (0, import_types44.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -15342,7 +15477,7 @@ init_cjs_shims();
 var import_node_path60 = __toESM(require("path"), 1);
 var import_tree_sitter16 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_go5 = __toESM(require("tree-sitter-go"), 1);
-var import_types44 = require("@neat.is/types");
+var import_types45 = require("@neat.is/types");
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK12 = 16384;
 function makeGoParser4() {
@@ -15787,7 +15922,7 @@ function gormEndpointsFromFile(file, serviceDir) {
     const columns = [];
     collectColumns(struct, structs, /* @__PURE__ */ new Set(), "", columns, /* @__PURE__ */ new Set());
     out.push({
-      infraId: (0, import_types44.infraId)("sql-table", table),
+      infraId: (0, import_types45.infraId)("sql-table", table),
       name: table,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -15858,7 +15993,7 @@ init_cjs_shims();
 var import_node_path61 = __toESM(require("path"), 1);
 var import_tree_sitter17 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_c_sharp2 = __toESM(require("tree-sitter-c-sharp"), 1);
-var import_types45 = require("@neat.is/types");
+var import_types46 = require("@neat.is/types");
 var EFCORE_GATE = /Microsoft\.EntityFrameworkCore|DataAnnotations\.Schema|\bDbContext\b|\bDbSet\s*</;
 var PARSE_CHUNK13 = 16384;
 function makeCsParser() {
@@ -15943,7 +16078,7 @@ function efcoreEndpointsFromFile(file, serviceDir) {
     if (!name || seen.has(name)) return;
     seen.add(name);
     out.push({
-      infraId: (0, import_types45.infraId)("sql-table", name),
+      infraId: (0, import_types46.infraId)("sql-table", name),
       name,
       kind: "sql-table",
       edgeType: "CALLS",
@@ -15973,11 +16108,11 @@ function efcoreEndpointsFromFile(file, serviceDir) {
 function edgeTypeFromEndpoint(ep) {
   switch (ep.edgeType) {
     case "PUBLISHES_TO":
-      return import_types46.EdgeType.PUBLISHES_TO;
+      return import_types47.EdgeType.PUBLISHES_TO;
     case "CONSUMES_FROM":
-      return import_types46.EdgeType.CONSUMES_FROM;
+      return import_types47.EdgeType.CONSUMES_FROM;
     default:
-      return import_types46.EdgeType.CALLS;
+      return import_types47.EdgeType.CALLS;
   }
 }
 function isAwsKind(kind) {
@@ -16048,7 +16183,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: import_types46.NodeType.InfraNode,
+          type: import_types47.NodeType.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -16061,21 +16196,21 @@ async function addExternalEndpointEdges(graph, services) {
       }
       if (ep.columns && ep.columns.length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === import_types46.NodeType.InfraNode) {
+        if (node.type === import_types47.NodeType.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldColumns(
               node.columns,
               ep.columns,
-              import_types46.Provenance.EXTRACTED,
-              (0, import_types46.confidenceForExtracted)(ep.confidenceKind)
+              import_types47.Provenance.EXTRACTED,
+              (0, import_types47.confidenceForExtracted)(ep.confidenceKind)
             )
           });
         }
       }
       if (ep.sdkWrites && Object.keys(ep.sdkWrites).length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === import_types46.NodeType.InfraNode) {
+        if (node.type === import_types47.NodeType.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldSdkWrites(node.columns, ep.sdkWrites)
@@ -16083,7 +16218,7 @@ async function addExternalEndpointEdges(graph, services) {
         }
       }
       const edgeType = edgeTypeFromEndpoint(ep);
-      const confidence = (0, import_types46.confidenceForExtracted)(ep.confidenceKind);
+      const confidence = (0, import_types47.confidenceForExtracted)(ep.confidenceKind);
       const relFile = toPosix(ep.evidence.file);
       const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
@@ -16093,7 +16228,7 @@ async function addExternalEndpointEdges(graph, services) {
       );
       nodesAdded += n;
       edgesAdded += e;
-      if (!(0, import_types46.passesExtractedFloor)(confidence)) {
+      if (!(0, import_types47.passesExtractedFloor)(confidence)) {
         noteExtractedDropped({
           source: fileNodeId,
           target: ep.infraId,
@@ -16113,7 +16248,7 @@ async function addExternalEndpointEdges(graph, services) {
           source: fileNodeId,
           target: ep.infraId,
           type: edgeType,
-          provenance: import_types46.Provenance.EXTRACTED,
+          provenance: import_types47.Provenance.EXTRACTED,
           confidence,
           evidence: ep.evidence
         };
@@ -16136,7 +16271,7 @@ async function addCallEdges(graph, services) {
 
 // src/extract/table-edges.ts
 init_cjs_shims();
-var import_types47 = require("@neat.is/types");
+var import_types48 = require("@neat.is/types");
 async function addTableEdges(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
@@ -16164,20 +16299,20 @@ async function addTableEdges(graph, services) {
     }
     refs.push(...modelRefs);
     for (const ref of refs) {
-      const childId = (0, import_types47.infraId)("sql-table", ref.childTable);
-      const parentId = (0, import_types47.infraId)("sql-table", ref.parentTable);
+      const childId = (0, import_types48.infraId)("sql-table", ref.childTable);
+      const parentId = (0, import_types48.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_types47.extractedEdgeId)(childId, parentId, import_types47.EdgeType.REFERENCES);
+      const edgeId = (0, import_types48.extractedEdgeId)(childId, parentId, import_types48.EdgeType.REFERENCES);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: childId,
         target: parentId,
-        type: import_types47.EdgeType.REFERENCES,
-        provenance: import_types47.Provenance.EXTRACTED,
-        confidence: (0, import_types47.confidenceForExtracted)("structural"),
+        type: import_types48.EdgeType.REFERENCES,
+        provenance: import_types48.Provenance.EXTRACTED,
+        confidence: (0, import_types48.confidenceForExtracted)("structural"),
         evidence: ref.evidence
       };
       graph.addEdgeWithKey(edgeId, childId, parentId, edge);
@@ -16190,7 +16325,7 @@ function ensureTableNode(graph, id, name) {
   if (graph.hasNode(id)) return 0;
   const node = {
     id,
-    type: import_types47.NodeType.InfraNode,
+    type: import_types48.NodeType.InfraNode,
     name,
     provider: "self",
     kind: "sql-table"
@@ -16205,15 +16340,15 @@ init_cjs_shims();
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
 var import_node_path62 = __toESM(require("path"), 1);
-var import_types49 = require("@neat.is/types");
+var import_types50 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
 init_cjs_shims();
-var import_types48 = require("@neat.is/types");
+var import_types49 = require("@neat.is/types");
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
-    id: (0, import_types48.infraId)(kind, name),
-    type: import_types48.NodeType.InfraNode,
+    id: (0, import_types49.infraId)(kind, name),
+    type: import_types49.NodeType.InfraNode,
     name,
     provider,
     kind,
@@ -16257,8 +16392,8 @@ function emitPlatformResourceEdge(graph, anchorId, edgeType, kind, name, provide
       source: anchorId,
       target: node.id,
       type: edgeType,
-      provenance: import_types48.Provenance.EXTRACTED,
-      confidence: (0, import_types48.confidenceForExtracted)("structural"),
+      provenance: import_types49.Provenance.EXTRACTED,
+      confidence: (0, import_types49.confidenceForExtracted)("structural"),
       evidence: { file: evidenceFile, ...line !== void 0 ? { line } : {} }
     };
     graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -16325,15 +16460,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_types49.EdgeType.DEPENDS_ON);
+      const edgeId = (0, import_types3.extractedEdgeId)(sourceId, targetId, import_types50.EdgeType.DEPENDS_ON);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: sourceId,
         target: targetId,
-        type: import_types49.EdgeType.DEPENDS_ON,
-        provenance: import_types49.Provenance.EXTRACTED,
-        confidence: (0, import_types49.confidenceForExtracted)("structural"),
+        type: import_types50.EdgeType.DEPENDS_ON,
+        provenance: import_types50.Provenance.EXTRACTED,
+        confidence: (0, import_types50.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -16347,7 +16482,7 @@ async function addComposeInfra(graph, scanPath, services) {
 init_cjs_shims();
 var import_node_path63 = __toESM(require("path"), 1);
 var import_node_fs29 = require("fs");
-var import_types50 = require("@neat.is/types");
+var import_types51 = require("@neat.is/types");
 function readDockerfile(content) {
   let image = null;
   const ports = [];
@@ -16406,15 +16541,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
     );
     nodesAdded += fn;
     edgesAdded += fe;
-    const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types50.EdgeType.RUNS_ON);
+    const edgeId = (0, import_types3.extractedEdgeId)(fileNodeId, node.id, import_types51.EdgeType.RUNS_ON);
     if (!graph.hasEdge(edgeId)) {
       const edge = {
         id: edgeId,
         source: fileNodeId,
         target: node.id,
-        type: import_types50.EdgeType.RUNS_ON,
-        provenance: import_types50.Provenance.EXTRACTED,
-        confidence: (0, import_types50.confidenceForExtracted)("structural"),
+        type: import_types51.EdgeType.RUNS_ON,
+        provenance: import_types51.Provenance.EXTRACTED,
+        confidence: (0, import_types51.confidenceForExtracted)("structural"),
         evidence: {
           file: evidenceFile,
           ...facts.entrypoint ? { snippet: facts.entrypoint.slice(0, 120) } : {}
@@ -16429,15 +16564,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
         graph.addNode(portNode.id, portNode);
         nodesAdded++;
       }
-      const portEdgeId = (0, import_types3.extractedEdgeId)(fileNodeId, portNode.id, import_types50.EdgeType.CONNECTS_TO);
+      const portEdgeId = (0, import_types3.extractedEdgeId)(fileNodeId, portNode.id, import_types51.EdgeType.CONNECTS_TO);
       if (graph.hasEdge(portEdgeId)) continue;
       const portEdge = {
         id: portEdgeId,
         source: fileNodeId,
         target: portNode.id,
-        type: import_types50.EdgeType.CONNECTS_TO,
-        provenance: import_types50.Provenance.EXTRACTED,
-        confidence: (0, import_types50.confidenceForExtracted)("structural"),
+        type: import_types51.EdgeType.CONNECTS_TO,
+        provenance: import_types51.Provenance.EXTRACTED,
+        confidence: (0, import_types51.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile, snippet: `EXPOSE ${port}` }
       };
       graph.addEdgeWithKey(portEdgeId, portEdge.source, portEdge.target, portEdge);
@@ -16451,7 +16586,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 init_cjs_shims();
 var import_node_fs30 = require("fs");
 var import_node_path64 = __toESM(require("path"), 1);
-var import_types51 = require("@neat.is/types");
+var import_types52 = 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) {
@@ -16532,16 +16667,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_types51.EdgeType.DEPENDS_ON);
+        const edgeId = (0, import_types3.extractedEdgeId)(resource.nodeId, target.nodeId, import_types52.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_types51.EdgeType.DEPENDS_ON,
-          provenance: import_types51.Provenance.EXTRACTED,
-          confidence: (0, import_types51.confidenceForExtracted)("structural"),
+          type: import_types52.EdgeType.DEPENDS_ON,
+          provenance: import_types52.Provenance.EXTRACTED,
+          confidence: (0, import_types52.confidenceForExtracted)("structural"),
           evidence: { file: evidenceFile, line, snippet: key }
         };
         graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -16557,7 +16692,7 @@ init_cjs_shims();
 var import_node_fs31 = require("fs");
 var import_node_path65 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
-var import_types52 = require("@neat.is/types");
+var import_types53 = require("@neat.is/types");
 var K8S_KIND_TO_INFRA_KIND = {
   Service: "k8s-service",
   Deployment: "k8s-deployment",
@@ -16617,7 +16752,7 @@ async function addK8sResources(graph, scanPath) {
         nodesAdded++;
       }
       if (isWorkload) {
-        const svcId = (0, import_types52.serviceId)(name);
+        const svcId = (0, import_types53.serviceId)(name);
         if (graph.hasNode(svcId)) {
           const svc = graph.getNodeAttributes(svcId);
           graph.replaceNodeAttributes(svcId, {
@@ -16629,7 +16764,7 @@ async function addK8sResources(graph, scanPath) {
           edgesAdded += emitPlatformResourceEdge(
             graph,
             svcId,
-            import_types52.EdgeType.RUNS_ON,
+            import_types53.EdgeType.RUNS_ON,
             infraKind,
             name,
             "kubernetes",
@@ -16648,7 +16783,7 @@ init_cjs_shims();
 var import_node_fs32 = require("fs");
 var import_node_path66 = __toESM(require("path"), 1);
 var import_smol_toml3 = require("smol-toml");
-var import_types53 = require("@neat.is/types");
+var import_types54 = require("@neat.is/types");
 var WRANGLER_FILENAMES = ["wrangler.toml", "wrangler.jsonc", "wrangler.json"];
 async function readWranglerConfig(dir) {
   for (const filename of WRANGLER_FILENAMES) {
@@ -16696,8 +16831,8 @@ function addResourceEdge(graph, anchorId, edgeType, kind, name, evidenceFile, li
       source: anchorId,
       target: node.id,
       type: edgeType,
-      provenance: import_types53.Provenance.EXTRACTED,
-      confidence: (0, import_types53.confidenceForExtracted)("structural"),
+      provenance: import_types54.Provenance.EXTRACTED,
+      confidence: (0, import_types54.confidenceForExtracted)("structural"),
       evidence: { file: evidenceFile, ...line !== void 0 ? { line } : {} }
     };
     graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -16758,15 +16893,15 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       nodesAdded++;
     }
     if (runtimeNode.id !== anchorId) {
-      const runsOnId = (0, import_types3.extractedEdgeId)(anchorId, runtimeNode.id, import_types53.EdgeType.RUNS_ON);
+      const runsOnId = (0, import_types3.extractedEdgeId)(anchorId, runtimeNode.id, import_types54.EdgeType.RUNS_ON);
       if (!graph.hasEdge(runsOnId)) {
         const edge = {
           id: runsOnId,
           source: anchorId,
           target: runtimeNode.id,
-          type: import_types53.EdgeType.RUNS_ON,
-          provenance: import_types53.Provenance.EXTRACTED,
-          confidence: (0, import_types53.confidenceForExtracted)("structural"),
+          type: import_types54.EdgeType.RUNS_ON,
+          provenance: import_types54.Provenance.EXTRACTED,
+          confidence: (0, import_types54.confidenceForExtracted)("structural"),
           evidence: {
             file: evidenceFile,
             ...config.compatibility_date ? { snippet: `compatibility_date = ${config.compatibility_date}`.slice(0, 120) } : {}
@@ -16780,7 +16915,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types53.EdgeType.CONNECTS_TO,
+        import_types54.EdgeType.CONNECTS_TO,
         "cloudflare-route",
         route,
         evidenceFile,
@@ -16804,7 +16939,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
         const result = addResourceEdge(
           graph,
           anchorId,
-          import_types53.EdgeType.DEPENDS_ON,
+          import_types54.EdgeType.DEPENDS_ON,
           group.kind,
           name,
           evidenceFile,
@@ -16818,7 +16953,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types53.EdgeType.DEPENDS_ON,
+        import_types54.EdgeType.DEPENDS_ON,
         "cloudflare-cron",
         cron,
         evidenceFile,
@@ -16831,7 +16966,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types53.EdgeType.DEPENDS_ON,
+        import_types54.EdgeType.DEPENDS_ON,
         "cloudflare-env-var",
         varName,
         evidenceFile,
@@ -16844,15 +16979,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_types53.EdgeType.CALLS);
+        const edgeId = (0, import_types3.extractedEdgeId)(anchorId, target.anchorId, import_types54.EdgeType.CALLS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: anchorId,
             target: target.anchorId,
-            type: import_types53.EdgeType.CALLS,
-            provenance: import_types53.Provenance.EXTRACTED,
-            confidence: (0, import_types53.confidenceForExtracted)("structural"),
+            type: import_types54.EdgeType.CALLS,
+            provenance: import_types54.Provenance.EXTRACTED,
+            confidence: (0, import_types54.confidenceForExtracted)("structural"),
             evidence: { file: evidenceFile, line: lineContaining2(raw, svc.service) }
           };
           graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -16863,7 +16998,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
       const result = addResourceEdge(
         graph,
         anchorId,
-        import_types53.EdgeType.DEPENDS_ON,
+        import_types54.EdgeType.DEPENDS_ON,
         "cloudflare-service-binding",
         svc.service,
         evidenceFile,
@@ -16880,7 +17015,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 init_cjs_shims();
 var import_node_fs33 = require("fs");
 var import_node_path67 = __toESM(require("path"), 1);
-var import_types54 = require("@neat.is/types");
+var import_types55 = require("@neat.is/types");
 var VERCEL_CONFIG_FILENAMES = ["vercel.json", "vercel.jsonc"];
 async function readVercelConfig(dir) {
   for (const filename of VERCEL_CONFIG_FILENAMES) {
@@ -16943,12 +17078,12 @@ async function addVercelServices(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types54.EdgeType.RUNS_ON, "vercel", "vercel");
-    for (const cron of config.crons ?? []) add(import_types54.EdgeType.DEPENDS_ON, "vercel-cron", cron.path ?? cron.schedule);
-    for (const varName of Object.keys(config.env ?? {})) add(import_types54.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
-    for (const varName of Object.keys(config.build?.env ?? {})) add(import_types54.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
+    add(import_types55.EdgeType.RUNS_ON, "vercel", "vercel");
+    for (const cron of config.crons ?? []) add(import_types55.EdgeType.DEPENDS_ON, "vercel-cron", cron.path ?? cron.schedule);
+    for (const varName of Object.keys(config.env ?? {})) add(import_types55.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
+    for (const varName of Object.keys(config.build?.env ?? {})) add(import_types55.EdgeType.DEPENDS_ON, "vercel-env-var", varName);
     for (const route of [...config.rewrites ?? [], ...config.redirects ?? [], ...config.routes ?? []]) {
-      add(import_types54.EdgeType.CONNECTS_TO, "vercel-route", routeSource(route));
+      add(import_types55.EdgeType.CONNECTS_TO, "vercel-route", routeSource(route));
     }
   }
   return { nodesAdded, edgesAdded };
@@ -16959,7 +17094,7 @@ init_cjs_shims();
 var import_node_fs34 = require("fs");
 var import_node_path68 = __toESM(require("path"), 1);
 var import_smol_toml4 = require("smol-toml");
-var import_types55 = require("@neat.is/types");
+var import_types56 = require("@neat.is/types");
 var RAILWAY_FILENAMES = ["railway.toml", "railway.json", "railway.jsonc"];
 async function readRailwayConfig(dir) {
   for (const filename of RAILWAY_FILENAMES) {
@@ -17005,9 +17140,9 @@ async function addRailwayServices(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types55.EdgeType.RUNS_ON, "railway", "railway");
-    add(import_types55.EdgeType.CONNECTS_TO, "railway-route", config.deploy?.healthcheckPath);
-    add(import_types55.EdgeType.DEPENDS_ON, "railway-cron", config.deploy?.cronSchedule);
+    add(import_types56.EdgeType.RUNS_ON, "railway", "railway");
+    add(import_types56.EdgeType.CONNECTS_TO, "railway-route", config.deploy?.healthcheckPath);
+    add(import_types56.EdgeType.DEPENDS_ON, "railway-cron", config.deploy?.cronSchedule);
   }
   return { nodesAdded, edgesAdded };
 }
@@ -17017,7 +17152,7 @@ init_cjs_shims();
 var import_node_fs35 = require("fs");
 var import_node_path69 = __toESM(require("path"), 1);
 var import_smol_toml5 = require("smol-toml");
-var import_types56 = require("@neat.is/types");
+var import_types57 = require("@neat.is/types");
 async function readSupabaseConfig(dir) {
   const relFile = import_node_path69.default.join("supabase", "config.toml");
   const abs = import_node_path69.default.join(dir, relFile);
@@ -17065,10 +17200,10 @@ async function addSupabaseProjects(graph, services, scanPath) {
       nodesAdded += result.nodesAdded;
       edgesAdded += result.edgesAdded;
     };
-    add(import_types56.EdgeType.RUNS_ON, "supabase", "supabase");
-    for (const fn of Object.keys(config.functions ?? {})) add(import_types56.EdgeType.DEPENDS_ON, "supabase-function", fn);
-    if (config.storage) add(import_types56.EdgeType.DEPENDS_ON, "supabase-storage", "storage");
-    if (config.auth) add(import_types56.EdgeType.DEPENDS_ON, "supabase-auth", "auth");
+    add(import_types57.EdgeType.RUNS_ON, "supabase", "supabase");
+    for (const fn of Object.keys(config.functions ?? {})) add(import_types57.EdgeType.DEPENDS_ON, "supabase-function", fn);
+    if (config.storage) add(import_types57.EdgeType.DEPENDS_ON, "supabase-storage", "storage");
+    if (config.auth) add(import_types57.EdgeType.DEPENDS_ON, "supabase-auth", "auth");
   }
   return { nodesAdded, edgesAdded };
 }
@@ -17094,7 +17229,7 @@ init_cjs_shims();
 var import_node_path70 = __toESM(require("path"), 1);
 var import_tree_sitter18 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript8 = __toESM(require("tree-sitter-javascript"), 1);
-var import_types57 = require("@neat.is/types");
+var import_types58 = require("@neat.is/types");
 var ZOD_IMPORT_RE = /\bzod\b/;
 var ZOD_OBJECTS = /* @__PURE__ */ new Set(["z", "zod"]);
 function parserForExt4(ext) {
@@ -17200,7 +17335,7 @@ function zodShapesFromFile(file, serviceDir) {
     seen.add(name);
     const line = call.startPosition.row + 1;
     out.push({
-      infraId: (0, import_types57.infraId)("zod-schema", name),
+      infraId: (0, import_types58.infraId)("zod-schema", name),
       name,
       fields,
       evidence: {
@@ -17235,7 +17370,7 @@ async function addZodShapes(graph, services) {
         if (!graph.hasNode(shape.infraId)) {
           const node = {
             id: shape.infraId,
-            type: import_types57.NodeType.InfraNode,
+            type: import_types58.NodeType.InfraNode,
             name: shape.name,
             provider: "self",
             kind: "zod-schema"
@@ -17245,14 +17380,14 @@ async function addZodShapes(graph, services) {
         }
         if (shape.fields.length > 0) {
           const node = graph.getNodeAttributes(shape.infraId);
-          if (node.type === import_types57.NodeType.InfraNode) {
+          if (node.type === import_types58.NodeType.InfraNode) {
             graph.replaceNodeAttributes(shape.infraId, {
               ...node,
               columns: foldColumns(
                 node.columns,
                 shape.fields,
-                import_types57.Provenance.EXTRACTED,
-                (0, import_types57.confidenceForExtracted)("structural")
+                import_types58.Provenance.EXTRACTED,
+                (0, import_types58.confidenceForExtracted)("structural")
               )
             });
           }
@@ -17266,15 +17401,15 @@ async function addZodShapes(graph, services) {
         );
         nodesAdded += n;
         edgesAdded += e;
-        const edgeId = (0, import_types57.extractedEdgeId)(fileNodeId, shape.infraId, import_types57.EdgeType.CONTAINS);
+        const edgeId = (0, import_types58.extractedEdgeId)(fileNodeId, shape.infraId, import_types58.EdgeType.CONTAINS);
         if (!graph.hasEdge(edgeId)) {
           const edge = {
             id: edgeId,
             source: fileNodeId,
             target: shape.infraId,
-            type: import_types57.EdgeType.CONTAINS,
-            provenance: import_types57.Provenance.EXTRACTED,
-            confidence: (0, import_types57.confidenceForExtracted)("structural"),
+            type: import_types58.EdgeType.CONTAINS,
+            provenance: import_types58.Provenance.EXTRACTED,
+            confidence: (0, import_types58.confidenceForExtracted)("structural"),
             evidence: shape.evidence
           };
           graph.addEdgeWithKey(edgeId, fileNodeId, shape.infraId, edge);
@@ -17288,7 +17423,7 @@ async function addZodShapes(graph, services) {
 
 // src/extract/firestore-rules.ts
 init_cjs_shims();
-var import_types58 = require("@neat.is/types");
+var import_types59 = require("@neat.is/types");
 var FIRESTORE_COLLECTION_KIND = "firestore-collection";
 var WRITE_METHODS = /* @__PURE__ */ new Set(["write", "create", "update"]);
 function stripComments(src) {
@@ -17459,7 +17594,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_types58.NodeType.InfraNode) return;
+    if (node.type !== import_types59.NodeType.InfraNode) return;
     if (node.kind !== FIRESTORE_COLLECTION_KIND) return;
     const fields = guards.get(collectionKeyFromName(node.name));
     if (!fields || fields.size === 0) return;
@@ -17478,12 +17613,12 @@ var import_node_path72 = __toESM(require("path"), 1);
 init_cjs_shims();
 var import_node_fs36 = require("fs");
 var import_node_path71 = __toESM(require("path"), 1);
-var import_types59 = require("@neat.is/types");
+var import_types60 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph, source) {
   const orphans = [];
   graph.forEachNode((id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types59.NodeType.FileNode) return;
+    if (node.type !== import_types60.NodeType.FileNode) return;
     if (source && node.source !== source) return;
     if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
       orphans.push(id);
@@ -17497,7 +17632,7 @@ function outOfScope(graph, edge, source) {
   for (const endpoint2 of [edge.source, edge.target]) {
     if (!graph.hasNode(endpoint2)) continue;
     const node = graph.getNodeAttributes(endpoint2);
-    if (node.type !== import_types59.NodeType.FileNode) continue;
+    if (node.type !== import_types60.NodeType.FileNode) continue;
     return node.source !== source;
   }
   return false;
@@ -17507,7 +17642,7 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = [], so
   const bases = [scanPath, ...serviceDirs];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== import_types59.Provenance.EXTRACTED) return;
+    if (edge.provenance !== import_types60.Provenance.EXTRACTED) return;
     if (outOfScope(graph, edge, source)) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
@@ -17526,7 +17661,23 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = [], so
 // src/extract/index.ts
 var passQueue = Promise.resolve();
 function extractFromDirectory(graph, scanPath, opts = {}) {
-  const pass = passQueue.then(() => runExtractionPass(graph, scanPath, opts));
+  invalidateSourceBaseline(graph, opts.source, "syncing");
+  const pass = passQueue.then(async () => {
+    const sourceGeneration = beginSourceExtraction(graph, opts.source, opts.sourceCommit);
+    let result;
+    try {
+      result = await runExtractionPass(graph, scanPath, opts);
+      return result;
+    } finally {
+      finishSourceExtraction(
+        graph,
+        sourceGeneration,
+        opts.source,
+        opts.sourceCommit,
+        result ?? { extractionErrors: 1, skippedFiles: 0 }
+      );
+    }
+  });
   passQueue = pass.catch(() => {
   });
   return pass;
@@ -17620,7 +17771,7 @@ async function runExtractionPass(graph, scanPath, opts) {
 
 // src/goodybag.ts
 init_cjs_shims();
-var import_types60 = require("@neat.is/types");
+var import_types61 = require("@neat.is/types");
 var CODE_FILEPATH_ATTR2 = "code.filepath";
 var CODE_LINENO_ATTR2 = "code.lineno";
 var BLAST_NEAREST_LIMIT = 5;
@@ -17646,7 +17797,7 @@ function locusOf(graph, ev) {
     ...Number.isFinite(line) ? { lineStart: line, lineEnd: line } : {},
     ...symbol ? { symbol } : {},
     service: node?.service ?? ev.service,
-    provenance: import_types60.Provenance.OBSERVED
+    provenance: import_types61.Provenance.OBSERVED
   };
 }
 function locusFromNode(graph, nodeId) {
@@ -17662,7 +17813,7 @@ function locusFromNode(graph, nodeId) {
     ...typeof end === "number" ? { lineEnd: end } : {},
     ...n.qualname ? { symbol: shortLabel(graph, nodeId) } : {},
     ...n.service ? { service: n.service } : {},
-    provenance: import_types60.Provenance.INFERRED
+    provenance: import_types61.Provenance.INFERRED
   };
 }
 function promoteCauseLocus(graph, causeNode, incidents) {
@@ -17671,7 +17822,7 @@ function promoteCauseLocus(graph, causeNode, incidents) {
   );
   if (native) {
     const l = locusOf(graph, native);
-    if (l) return { ...l, symbol: shortLabel(graph, causeNode), provenance: import_types60.Provenance.INFERRED };
+    if (l) return { ...l, symbol: shortLabel(graph, causeNode), provenance: import_types61.Provenance.INFERRED };
   }
   return locusFromNode(graph, causeNode);
 }
@@ -17720,7 +17871,7 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
     const chain = (rc.traversalPath ?? []).map((node, i) => ({
       node,
       grain: grainOf2(graph, node),
-      provenance: provs[i] ?? provs[provs.length - 1] ?? import_types60.Provenance.INFERRED
+      provenance: provs[i] ?? provs[provs.length - 1] ?? import_types61.Provenance.INFERRED
     }));
     rootCause = {
       node: rc.rootCauseNode,
@@ -17751,7 +17902,7 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
     kind: "incident",
     id: errorEvent.id,
     at: errorEvent.timestamp,
-    incidentKind: (0, import_types60.incidentKindOf)(errorEvent),
+    incidentKind: (0, import_types61.incidentKindOf)(errorEvent),
     service: errorEvent.service,
     affectedNode: affected,
     message: errorEvent.errorMessage,
@@ -17769,7 +17920,7 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
     headline: renderHeadline(graph, errorEvent, locus, rootCause?.node ?? null)
   };
   card.grade = gradeIncidentCard(card);
-  return import_types60.IncidentCardSchema.parse(card);
+  return import_types61.IncidentCardSchema.parse(card);
 }
 var GRADE_PRIORS_VERSION = "sniper-architecture-priors-2026-10-08";
 var GRADE_WEIGHTS = {
@@ -17876,7 +18027,7 @@ function gradeIncidentCard(card) {
 
 // src/ask.ts
 init_cjs_shims();
-var import_types61 = require("@neat.is/types");
+var import_types62 = require("@neat.is/types");
 var DEFAULT_MAX_NODES = 3;
 var MAX_FACTS_PER_SECTION = 6;
 var INTENT_RULES = [
@@ -18112,11 +18263,11 @@ function idBody(id) {
   return colon >= 0 ? id.slice(colon + 1) : id;
 }
 var TYPE_NOUNS = [
-  { nouns: ["database", "db", "table"], type: import_types61.NodeType.DatabaseNode },
-  { nouns: ["service", "api", "backend"], type: import_types61.NodeType.ServiceNode },
-  { nouns: ["route", "endpoint"], type: import_types61.NodeType.RouteNode },
-  { nouns: ["file"], type: import_types61.NodeType.FileNode },
-  { nouns: ["config"], type: import_types61.NodeType.ConfigNode }
+  { nouns: ["database", "db", "table"], type: import_types62.NodeType.DatabaseNode },
+  { nouns: ["service", "api", "backend"], type: import_types62.NodeType.ServiceNode },
+  { nouns: ["route", "endpoint"], type: import_types62.NodeType.RouteNode },
+  { nouns: ["file"], type: import_types62.NodeType.FileNode },
+  { nouns: ["config"], type: import_types62.NodeType.ConfigNode }
 ];
 var EMBED_MIN_SCORE = 0.35;
 async function resolveEntities(graph, question, searchIndex, maxNodes) {
@@ -18130,7 +18281,7 @@ async function resolveEntities(graph, question, searchIndex, maxNodes) {
   };
   graph.forEachNode((id, attrs) => {
     const node = attrs;
-    if (node.type === import_types61.NodeType.FrontierNode) return;
+    if (node.type === import_types62.NodeType.FrontierNode) return;
     const name = nodeName(node);
     const body = idBody(id);
     const labelTokens = /* @__PURE__ */ new Set([...tokens(body), ...tokens(name)]);
@@ -18149,7 +18300,7 @@ async function resolveEntities(graph, question, searchIndex, maxNodes) {
       const res = await searchIndex.search(question, 10);
       if (res.provider !== "substring") {
         for (const m of res.matches) {
-          if (m.node.type === import_types61.NodeType.FrontierNode) continue;
+          if (m.node.type === import_types62.NodeType.FrontierNode) continue;
           if (!graph.hasNode(m.node.id)) continue;
           const already = best.get(m.node.id);
           if (!already && m.score < EMBED_MIN_SCORE) continue;
@@ -18209,7 +18360,7 @@ function edgeSignalNote(e) {
 function buildRootCauseSection(graph, node, incidents, now) {
   const result = getRootCause(graph, node, void 0, incidents, { now });
   if (!result) return null;
-  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? import_types61.Provenance.OBSERVED;
+  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? import_types62.Provenance.OBSERVED;
   const facts = [
     {
       text: `Root cause: ${result.rootCauseNode} \u2014 ${result.rootCauseReason}`,
@@ -18259,7 +18410,7 @@ function buildObservedSection(graph, node) {
     if (result.observed && result.inboundObservedCount > 0) {
       facts.push({
         text: `no outbound runtime calls, but OTel observed ${result.inboundObservedCount} inbound call path${result.inboundObservedCount === 1 ? "" : "s"} \u2014 a pure receiver`,
-        provenance: import_types61.Provenance.OBSERVED
+        provenance: import_types62.Provenance.OBSERVED
       });
     } else {
       return null;
@@ -18282,10 +18433,10 @@ function buildBlastSection(graph, node) {
 }
 function buildDatabaseCallersSection(graph, node) {
   const callers = getBlastRadius(graph, node).affectedNodes.filter((item) => {
-    if (graph.getNodeAttributes(item.nodeId).type !== import_types61.NodeType.ServiceNode) return false;
+    if (graph.getNodeAttributes(item.nodeId).type !== import_types62.NodeType.ServiceNode) return false;
     return item.path.slice(1, -1).every((id) => {
       const type = graph.getNodeAttributes(id).type;
-      return type === import_types61.NodeType.FileNode || type === import_types61.NodeType.SymbolNode;
+      return type === import_types62.NodeType.FileNode || type === import_types62.NodeType.SymbolNode;
     });
   });
   return {
@@ -18304,7 +18455,7 @@ function buildIncidentsSection(node, incidents) {
   const facts = ordered.map((ev) => ({
     text: `${ev.timestamp} \u2014 ${ev.service}: ${ev.errorMessage}`,
     // ErrorEvents are observation records — OBSERVED by definition.
-    provenance: import_types61.Provenance.OBSERVED
+    provenance: import_types62.Provenance.OBSERVED
   }));
   return { heading: `Recent incidents (OBSERVED) \u2014 ${relevant.length} recorded`, facts };
 }
@@ -18327,8 +18478,8 @@ function runtimeEdgeState(graph) {
   let observed = false;
   let stale = false;
   graph.forEachEdge((_id, attrs) => {
-    if (attrs.provenance === import_types61.Provenance.OBSERVED) observed = true;
-    if (attrs.provenance === import_types61.Provenance.STALE) stale = true;
+    if (attrs.provenance === import_types62.Provenance.OBSERVED) observed = true;
+    if (attrs.provenance === import_types62.Provenance.STALE) stale = true;
   });
   return { observed, stale };
 }
@@ -18396,7 +18547,7 @@ function buildGlobalIncidentsSection(incidents) {
   }
   const byKey = /* @__PURE__ */ new Map();
   for (const ev of incidents) {
-    const key = ev.affectedNode || (0, import_types61.serviceId)(ev.service);
+    const key = ev.affectedNode || (0, import_types62.serviceId)(ev.service);
     const cur = byKey.get(key);
     if (!cur) {
       byKey.set(key, { key, count: 1, latest: ev.timestamp, sampleMsg: ev.errorMessage });
@@ -18411,7 +18562,7 @@ function buildGlobalIncidentsSection(incidents) {
   const rows = [...byKey.values()].sort((a, b) => b.count - a.count || b.latest.localeCompare(a.latest) || a.key.localeCompare(b.key)).slice(0, MAX_FACTS_PER_SECTION);
   const facts = rows.map((r) => ({
     text: `${r.key} \u2014 ${r.count} incident${r.count === 1 ? "" : "s"}, latest ${r.latest}: ${r.sampleMsg}`,
-    provenance: import_types61.Provenance.OBSERVED
+    provenance: import_types62.Provenance.OBSERVED
   }));
   return {
     heading: `Incidents across the system \u2014 ${incidents.length} recorded`,
@@ -18424,7 +18575,7 @@ function buildOverviewSections(graph, incidents) {
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
     nodeByType.set(node.type, (nodeByType.get(node.type) ?? 0) + 1);
-    if (node.type === import_types61.NodeType.ServiceNode) services.push(node.id);
+    if (node.type === import_types62.NodeType.ServiceNode) services.push(node.id);
   });
   const edgeByProv = /* @__PURE__ */ new Map();
   graph.forEachEdge((_id, attrs) => {
@@ -18436,10 +18587,10 @@ function buildOverviewSections(graph, incidents) {
   const shapeFacts = [
     { text: `${graph.order} nodes, ${graph.size} edges` },
     {
-      text: `${count(import_types61.NodeType.ServiceNode)} services, ${count(import_types61.NodeType.FileNode)} files, ${count(import_types61.NodeType.SymbolNode)} symbols, ${count(import_types61.NodeType.DatabaseNode)} databases`
+      text: `${count(import_types62.NodeType.ServiceNode)} services, ${count(import_types62.NodeType.FileNode)} files, ${count(import_types62.NodeType.SymbolNode)} symbols, ${count(import_types62.NodeType.DatabaseNode)} databases`
     }
   ];
-  for (const p of [import_types61.Provenance.EXTRACTED, import_types61.Provenance.OBSERVED, import_types61.Provenance.INFERRED, import_types61.Provenance.STALE]) {
+  for (const p of [import_types62.Provenance.EXTRACTED, import_types62.Provenance.OBSERVED, import_types62.Provenance.INFERRED, import_types62.Provenance.STALE]) {
     const n = edgeByProv.get(p) ?? 0;
     if (n > 0) shapeFacts.push({ text: `${n} ${p} edge${n === 1 ? "" : "s"}`, provenance: p });
   }
@@ -18456,7 +18607,7 @@ function buildOverviewSections(graph, incidents) {
   if (incidents && incidents.length > 0) {
     const incCount = /* @__PURE__ */ new Map();
     for (const ev of incidents) {
-      const key = ev.affectedNode || (0, import_types61.serviceId)(ev.service);
+      const key = ev.affectedNode || (0, import_types62.serviceId)(ev.service);
       incCount.set(key, (incCount.get(key) ?? 0) + 1);
     }
     const top = [...incCount.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_FACTS_PER_SECTION);
@@ -18464,7 +18615,7 @@ function buildOverviewSections(graph, incidents) {
       heading: `Nodes with incidents \u2014 ${incidents.length} recorded`,
       facts: top.map(([k, n]) => ({
         text: `${k} \u2014 ${n} incident${n === 1 ? "" : "s"}`,
-        provenance: import_types61.Provenance.OBSERVED
+        provenance: import_types62.Provenance.OBSERVED
       }))
     });
   }
@@ -18595,7 +18746,7 @@ async function askGraph(graph, question, opts = {}) {
   let scope;
   if (primary) {
     scope = "node";
-    const callersQuestion = intent === "dependencies" && graph.getNodeAttributes(primary).type === import_types61.NodeType.DatabaseNode && /\b(?:which|what)\s+services?\s+(?:talks?\s+to|connects?\s+to|uses?|hits?|calls?|reads?\s+from|writes?\s+to)\b/i.test(question);
+    const callersQuestion = intent === "dependencies" && graph.getNodeAttributes(primary).type === import_types62.NodeType.DatabaseNode && /\b(?:which|what)\s+services?\s+(?:talks?\s+to|connects?\s+to|uses?|hits?|calls?|reads?\s+from|writes?\s+to)\b/i.test(question);
     if (callersQuestion) sections.push(buildDatabaseCallersSection(graph, primary));
     for (const kind of SECTION_ORDER[intent]) {
       if (callersQuestion && kind === "blast") continue;
@@ -18613,7 +18764,7 @@ async function askGraph(graph, question, opts = {}) {
   const provSet = /* @__PURE__ */ new Set();
   for (const s of sections) for (const f of s.facts) if (f.provenance) provSet.add(f.provenance);
   const confidence = sections[0]?.facts[0]?.confidence;
-  return import_types61.AskResultSchema.parse({
+  return import_types62.AskResultSchema.parse({
     question,
     intent,
     matched,
@@ -18707,7 +18858,7 @@ function canonicalJson(value) {
 init_cjs_shims();
 var import_node_fs38 = require("fs");
 var import_node_path73 = __toESM(require("path"), 1);
-var import_types62 = require("@neat.is/types");
+var import_types63 = require("@neat.is/types");
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -18731,7 +18882,7 @@ function migrateV5ToV6(payload) {
   if (Array.isArray(nodes)) {
     for (const node of nodes) {
       const attrs = node.attributes;
-      if (!attrs || attrs.type !== import_types62.NodeType.InfraNode) continue;
+      if (!attrs || attrs.type !== import_types63.NodeType.InfraNode) continue;
       if (attrs.kind !== "sql-table" && attrs.kind !== "supabase-table") continue;
       if (!Array.isArray(attrs.columns)) attrs.columns = [];
     }
@@ -18747,12 +18898,12 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = import_types62.Provenance.OBSERVED;
+      attrs.provenance = import_types63.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_types62.observedEdgeId)(source, target, type);
+        const newId = (0, import_types63.observedEdgeId)(source, target, type);
         attrs.id = newId;
         if (edge.key) edge.key = newId;
       }
@@ -18963,7 +19114,7 @@ init_cjs_shims();
 var import_node_fs39 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path75 = __toESM(require("path"), 1);
-var import_types63 = require("@neat.is/types");
+var import_types64 = require("@neat.is/types");
 function neatHome() {
   const override = process.env.NEAT_HOME;
   if (override && override.length > 0) return import_node_path75.default.resolve(override);
@@ -19053,7 +19204,7 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types63.RegistryFileSchema.parse(parsed);
+  return import_types64.RegistryFileSchema.parse(parsed);
 }
 async function getProject(name) {
   const reg = await readRegistry();
@@ -19070,11 +19221,11 @@ var DEFAULT_PRUNE_TTL_MS = 7 * DAY_MS2;
 init_cjs_shims();
 var import_node_fs40 = require("fs");
 var import_zod = require("zod");
-var import_types64 = require("@neat.is/types");
+var import_types65 = require("@neat.is/types");
 var SSE_HEARTBEAT_MS = 3e4;
 var SSE_BACKPRESSURE_CAP = 1e3;
 var INCIDENT_TRIGGER_STREAM_SCOPE = "incident-only-v1";
-var IncidentTriggerSchema = import_types64.IncidentEventPayloadSchema.extend({
+var IncidentTriggerSchema = import_types65.IncidentEventPayloadSchema.extend({
   incidentId: import_zod.z.string().regex(/^[A-Za-z0-9:_-]{1,100}$/),
   affectedNode: import_zod.z.string().min(1).max(512),
   service: import_zod.z.string().min(1).max(256),
@@ -19102,12 +19253,12 @@ function loadIncidentReplay(errorsPath, cursor) {
         if (!isExtractionFailure(row)) throw new Error("incident replay unavailable");
         continue;
       }
-      const event = import_types64.ErrorEventSchema.parse(row);
+      const event = import_types65.ErrorEventSchema.parse(row);
       const trigger = IncidentTriggerSchema.parse({
         incidentId: event.id,
         affectedNode: event.affectedNode,
         service: event.service,
-        incidentKind: (0, import_types64.incidentKindOf)(event),
+        incidentKind: (0, import_types65.incidentKindOf)(event),
         at: event.timestamp
       });
       const prior = seen.get(trigger.incidentId), encoded = JSON.stringify(trigger);
@@ -19482,7 +19633,7 @@ function renderVerdict({
 }
 
 // src/pr-verdict.ts
-var import_types65 = require("@neat.is/types");
+var import_types66 = require("@neat.is/types");
 
 // src/connectors/hosted-repos.ts
 init_cjs_shims();
@@ -19555,7 +19706,7 @@ var PrVerdictError = class extends Error {
   details;
 };
 function parsePrVerdictRequest(body) {
-  const parsed = import_types65.PrVerdictBodySchema.safeParse(body);
+  const parsed = import_types66.PrVerdictBodySchema.safeParse(body);
   if (!parsed.success) {
     throw new PrVerdictError("invalid pr-verdict body", 400, void 0, parsed.error.issues);
   }
@@ -19904,15 +20055,15 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 
 // src/connectors/index.ts
 init_cjs_shims();
-var import_types66 = require("@neat.is/types");
+var import_types67 = 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_types66.Provenance.EXTRACTED) continue;
-    const parsed = (0, import_types66.parseFileId)(edge.source);
+    if (edge.provenance !== import_types67.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types67.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;
@@ -19923,7 +20074,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_types66.NodeType.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== import_types67.NodeType.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -20605,23 +20756,23 @@ async function fetchPgStatStatements(connectionString, limit = DEFAULT_STATEMENT
 
 // src/connectors/supabase/resolve.ts
 init_cjs_shims();
-var import_types68 = require("@neat.is/types");
+var import_types69 = 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_types68.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
+    const subResourceId = (0, import_types69.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
     if (graph.hasNode(subResourceId)) {
-      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types68.EdgeType.CALLS };
+      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types69.EdgeType.CALLS };
     }
-    const bareResourceId = (0, import_types68.infraId)(signal.targetKind, signal.targetName);
+    const bareResourceId = (0, import_types69.infraId)(signal.targetKind, signal.targetName);
     if (graph.hasNode(bareResourceId)) {
-      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types68.EdgeType.CALLS };
+      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types69.EdgeType.CALLS };
     }
-    const projectLevelId = (0, import_types68.infraId)("supabase", config.nodeRef);
+    const projectLevelId = (0, import_types69.infraId)("supabase", config.nodeRef);
     if (graph.hasNode(projectLevelId)) {
-      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types68.EdgeType.CALLS };
+      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types69.EdgeType.CALLS };
     }
     return null;
   };
@@ -20714,7 +20865,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 
 // src/connectors/railway/index.ts
 init_cjs_shims();
-var import_types72 = require("@neat.is/types");
+var import_types73 = require("@neat.is/types");
 
 // src/connectors/railway/client.ts
 init_cjs_shims();
@@ -20865,7 +21016,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types72.NodeType.RouteNode) return;
+    if (node.type !== import_types73.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -20969,12 +21120,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_types72.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types73.EdgeType.CALLS };
     }
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: (0, import_types72.serviceId)(peerName), serviceName, edgeType: import_types72.EdgeType.CONNECTS_TO };
+      return { targetNodeId: (0, import_types73.serviceId)(peerName), serviceName, edgeType: import_types73.EdgeType.CONNECTS_TO };
     }
     return null;
   };
@@ -21162,11 +21313,11 @@ function mapLogEntriesToSignals(entries) {
 
 // src/connectors/firebase/resolve.ts
 init_cjs_shims();
-var import_types74 = require("@neat.is/types");
+var import_types75 = require("@neat.is/types");
 
 // src/connectors/infer-service.ts
 init_cjs_shims();
-var import_types73 = require("@neat.is/types");
+var import_types74 = require("@neat.is/types");
 function normalizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
@@ -21177,11 +21328,11 @@ function inferServiceName(graph, resourceName, method, path81) {
   const owners = /* @__PURE__ */ new Set();
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type === import_types73.NodeType.ServiceNode && typeof node.name === "string") {
+    if (node.type === import_types74.NodeType.ServiceNode && typeof node.name === "string") {
       services.push(node.name);
       return;
     }
-    if (node.type !== import_types73.NodeType.RouteNode) return;
+    if (node.type !== import_types74.NodeType.RouteNode) return;
     const route = attrs;
     if (!route.pathTemplate || normalizePathTemplate(route.pathTemplate) !== wantedPath) return;
     const routeMethod = route.method.toUpperCase();
@@ -21208,7 +21359,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types74.NodeType.RouteNode) return;
+    if (node.type !== import_types75.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -21240,7 +21391,7 @@ function createFirebaseResolveTarget(graph, serviceMap) {
     return {
       targetNodeId: match.routeNodeId,
       serviceName,
-      edgeType: import_types74.EdgeType.CALLS
+      edgeType: import_types75.EdgeType.CALLS
     };
   };
 }
@@ -21273,7 +21424,7 @@ init_cjs_shims();
 
 // src/connectors/cloudflare/connector.ts
 init_cjs_shims();
-var import_types76 = require("@neat.is/types");
+var import_types77 = require("@neat.is/types");
 
 // src/connectors/cloudflare/client.ts
 init_cjs_shims();
@@ -21437,7 +21588,7 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === import_types76.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === import_types77.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
@@ -21449,7 +21600,7 @@ function findMatchingRouteNode(graph, serviceName, method, path81) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types76.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types77.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;
@@ -21468,11 +21619,11 @@ function createCloudflareResolveTarget(config, graph) {
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
-      const wholeFileId = (0, import_types76.fileId)(mapping.service, mapping.entryFile);
+      const wholeFileId = (0, import_types77.fileId)(mapping.service, mapping.entryFile);
       return {
         targetNodeId: resolveRouteGrain(mapping.service, wholeFileId),
         serviceName: mapping.service,
-        edgeType: import_types76.EdgeType.CALLS
+        edgeType: import_types77.EdgeType.CALLS
       };
     }
     const taggedFileId = findTaggedWorkerFileNode(graph, scriptName);
@@ -21481,13 +21632,13 @@ function createCloudflareResolveTarget(config, graph) {
       return {
         targetNodeId: resolveRouteGrain(fileNode.service, taggedFileId),
         serviceName: fileNode.service,
-        edgeType: import_types76.EdgeType.CALLS
+        edgeType: import_types77.EdgeType.CALLS
       };
     }
     return {
-      targetNodeId: (0, import_types76.infraId)("cloudflare-worker", scriptName),
+      targetNodeId: (0, import_types77.infraId)("cloudflare-worker", scriptName),
       serviceName: scriptName,
-      edgeType: import_types76.EdgeType.CALLS,
+      edgeType: import_types77.EdgeType.CALLS,
       ensureInfraNode: { kind: "cloudflare-worker", name: scriptName, provider: "cloudflare" }
     };
   };
@@ -21683,14 +21834,14 @@ function diffNeonStatementsToSignals(rows, previous, observedAtIso) {
 
 // src/connectors/neon/resolve.ts
 init_cjs_shims();
-var import_types80 = require("@neat.is/types");
+var import_types81 = 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_types80.infraId)("sql-table", signal.targetName),
+      targetNodeId: (0, import_types81.infraId)("sql-table", signal.targetName),
       serviceName: config.serviceName,
-      edgeType: import_types80.EdgeType.CALLS,
+      edgeType: import_types81.EdgeType.CALLS,
       ensureInfraNode: { kind: "sql-table", name: signal.targetName, provider: "neon" }
     };
   };
@@ -21871,14 +22022,14 @@ function mapLogEntriesToSignals2(entries) {
 
 // src/connectors/cloud-run/resolve.ts
 init_cjs_shims();
-var import_types84 = require("@neat.is/types");
+var import_types85 = 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_types84.NodeType.RouteNode) return;
+    if (node.type !== import_types85.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -21903,13 +22054,13 @@ function createCloudRunResolveTarget(graph, config) {
         normalizePathTemplate(path81)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types84.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types85.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types84.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
+      targetNodeId: (0, import_types85.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
       serviceName: mappedService ?? gcpServiceName,
-      edgeType: import_types84.EdgeType.CALLS,
+      edgeType: import_types85.EdgeType.CALLS,
       ensureInfraNode: {
         kind: CLOUD_RUN_SERVICE_INFRA_KIND,
         name: gcpServiceName,
@@ -22091,14 +22242,14 @@ function mapLogEntriesToSignals3(entries) {
 
 // src/connectors/gcp-lb/resolve.ts
 init_cjs_shims();
-var import_types88 = require("@neat.is/types");
+var import_types89 = require("@neat.is/types");
 var GCP_LB_BACKEND_INFRA_KIND = "gcp-lb-backend";
 function findMatchingRouteNode3(graph, serviceName, method, normalizedPath) {
   let found = null;
   graph.forEachNode((_id, attrs) => {
     if (found) return;
     const node = attrs;
-    if (node.type !== import_types88.NodeType.RouteNode) return;
+    if (node.type !== import_types89.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -22123,13 +22274,13 @@ function createGcpLbResolveTarget(graph, config) {
         normalizePathTemplate(path81)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types88.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types89.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types88.infraId)(GCP_LB_BACKEND_INFRA_KIND, backendServiceName),
+      targetNodeId: (0, import_types89.infraId)(GCP_LB_BACKEND_INFRA_KIND, backendServiceName),
       serviceName: mappedService ?? backendServiceName,
-      edgeType: import_types88.EdgeType.CALLS,
+      edgeType: import_types89.EdgeType.CALLS,
       ensureInfraNode: {
         kind: GCP_LB_BACKEND_INFRA_KIND,
         name: backendServiceName,
@@ -22170,7 +22321,7 @@ function createGcpLbConnector(graph, config = {}) {
 
 // src/connectors/render/index.ts
 init_cjs_shims();
-var import_types91 = require("@neat.is/types");
+var import_types92 = require("@neat.is/types");
 
 // src/connectors/render/types.ts
 init_cjs_shims();
@@ -22248,7 +22399,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types91.NodeType.RouteNode) return;
+    if (node.type !== import_types92.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -22333,7 +22484,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_types91.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types92.EdgeType.CALLS };
     }
     return null;
   };
@@ -22471,21 +22622,21 @@ function mapInsightsToSignals(rows, observedAtIso) {
 
 // src/connectors/planetscale/resolve.ts
 init_cjs_shims();
-var import_types95 = require("@neat.is/types");
+var import_types96 = 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_types95.infraId)("sql-table", signal.targetName);
+    const tableId = (0, import_types96.infraId)("sql-table", signal.targetName);
     if (graph.hasNode(tableId)) {
-      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types95.EdgeType.CALLS };
+      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types96.EdgeType.CALLS };
     }
-    const providerId = (0, import_types95.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
+    const providerId = (0, import_types96.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
     return {
       targetNodeId: providerId,
       serviceName: config.serviceName,
-      edgeType: import_types95.EdgeType.CALLS,
+      edgeType: import_types96.EdgeType.CALLS,
       ensureInfraNode: { kind: PLANETSCALE_DATABASE_KIND, name: databaseName, provider: "planetscale" }
     };
   };
@@ -22750,7 +22901,7 @@ function mapBuildsToSignals(builds, serviceName) {
 
 // src/connectors/eas/resolve.ts
 init_cjs_shims();
-var import_types100 = require("@neat.is/types");
+var import_types101 = 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([
@@ -22766,8 +22917,8 @@ function configBasenamesForPhase(phase) {
 function configNodeService(graph, configNodeId) {
   for (const edgeId of graph.inboundEdges(configNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types100.EdgeType.CONFIGURED_BY) continue;
-    const parsed = (0, import_types100.parseFileId)(edge.source);
+    if (edge.type !== import_types101.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types101.parseFileId)(edge.source);
     if (parsed) return parsed.service;
   }
   return null;
@@ -22778,7 +22929,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== import_types100.NodeType.ConfigNode) return;
+    if (node.type !== import_types101.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;
@@ -22795,13 +22946,13 @@ function createEasResolveTarget(graph) {
     if (basenames.length > 0) {
       const configNodeId = findConfigNode(graph, basenames, serviceName);
       if (configNodeId) {
-        return { targetNodeId: configNodeId, serviceName, edgeType: import_types100.EdgeType.CALLS };
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types101.EdgeType.CALLS };
       }
     }
     return {
       targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
       serviceName,
-      edgeType: import_types100.EdgeType.CALLS
+      edgeType: import_types101.EdgeType.CALLS
     };
   };
 }
@@ -23380,7 +23531,7 @@ function serializeGraph(graph) {
   graph.forEachEdge((_id, attrs) => {
     edges.push(attrs);
   });
-  return { nodes, edges };
+  return { nodes, edges, sourceBaselines: readSourceBaselines(graph) };
 }
 function projectFromReq(req, singleProject, registry) {
   const params = req.params;
@@ -23563,11 +23714,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_types103.DivergenceTypeSchema.safeParse(c);
+        const r = import_types104.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types103.DivergenceTypeSchema.options
+            allowed: import_types104.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -24004,7 +24155,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types103.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types104.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -24043,7 +24194,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_types103.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types104.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",