@neat.is/core 0.7.9 → 0.8.0-rc.1

package/dist/{chunk-N5TPODCX.js → chunk-3PXRQH53.js}

@@ -963,6 +963,7 @@ import { parse as parseYaml } from "yaml";
 import { extractedEdgeId } from "@neat.is/types";
 var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php"]);
 var CONFIG_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var JSON_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["app.json", "app.config.json", "eas.json"]);
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -1002,6 +1003,7 @@ async function isPythonVenvDir(dir) {
 function isConfigFile(name) {
   const ext = path3.extname(name);
   if (CONFIG_FILE_EXTENSIONS.has(ext)) return { match: true, fileType: ext.slice(1) };
+  if (JSON_CONFIG_FILENAMES.has(name)) return { match: true, fileType: "json" };
   if (name === ".env" || name.startsWith(".env.")) {
     if (isEnvTemplateFile(name)) return { match: false, fileType: "" };
     if (isNeatAuthoredEnvFile(name)) return { match: false, fileType: "" };
@@ -3339,6 +3341,62 @@ function columnIsObserved(col) {
   return col.provenances.includes(Provenance4.OBSERVED);
 }
 
+// src/latency-digest.ts
+var SUB = 16;
+var MIN_EXP = -10;
+var MAX_EXP = 22;
+var OCTAVES = MAX_EXP - MIN_EXP + 1;
+var OVERFLOW_INDEX = OCTAVES * SUB + 1;
+function latencyBucketIndex(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return 0;
+  const e = Math.floor(Math.log2(ms));
+  if (e < MIN_EXP) return 0;
+  if (e > MAX_EXP) return OVERFLOW_INDEX;
+  const base = 2 ** e;
+  const raw = Math.floor((ms / base - 1) * SUB);
+  const s = raw < 0 ? 0 : raw >= SUB ? SUB - 1 : raw;
+  return (e - MIN_EXP) * SUB + s + 1;
+}
+function bucketRepresentativeMs(index) {
+  if (index <= 0) return 0;
+  if (index >= OVERFLOW_INDEX) return 2 ** (MAX_EXP + 1);
+  const zeroBased = index - 1;
+  const e = MIN_EXP + Math.floor(zeroBased / SUB);
+  const s = zeroBased % SUB;
+  const base = 2 ** e;
+  const lower = base * (1 + s / SUB);
+  const upper = base * (1 + (s + 1) / SUB);
+  return (lower + upper) / 2;
+}
+function recordLatency(hist, ms) {
+  const key = String(latencyBucketIndex(ms));
+  hist[key] = (hist[key] ?? 0) + 1;
+  return hist;
+}
+function quantile(hist, q) {
+  const entries = Object.entries(hist).map(([k, c]) => [Number(k), c]).filter(([idx, c]) => Number.isFinite(idx) && c > 0).sort((a, b) => a[0] - b[0]);
+  let total = 0;
+  for (const [, c] of entries) total += c;
+  if (total === 0) return 0;
+  const rank = Math.max(1, Math.ceil(q * total));
+  let cumulative = 0;
+  for (const [idx, c] of entries) {
+    cumulative += c;
+    if (cumulative >= rank) return bucketRepresentativeMs(idx);
+  }
+  return bucketRepresentativeMs(entries[entries.length - 1][0]);
+}
+function round(ms) {
+  return Math.round(ms * 100) / 100;
+}
+function latencyPercentiles(hist) {
+  if (!hist) return void 0;
+  let total = 0;
+  for (const c of Object.values(hist)) total += c;
+  if (total === 0) return void 0;
+  return { p50: round(quantile(hist, 0.5)), p95: round(quantile(hist, 0.95)) };
+}
+
 // src/ingest.ts
 var HOUR_MS = 60 * 60 * 1e3;
 var DAY_MS = 24 * HOUR_MS;
@@ -4034,7 +4092,7 @@ function ensureFrontierNode(graph, host, ts) {
   graph.addNode(id, node);
   return id;
 }
-function upsertObservedEdge(graph, type, source, target, ts, isError = false, evidence) {
+function upsertObservedEdge(graph, type, source, target, ts, isError = false, evidence, durationMs) {
   if (!graph.hasNode(source) || !graph.hasNode(target)) return null;
   const grain = source.startsWith("file:") || source.startsWith("symbol:") ? "file" : "service";
   const id = makeObservedEdgeId(type, source, target);
@@ -4042,10 +4100,15 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     const existing = graph.getEdgeAttributes(id);
     const newSpanCount = (existing.signal?.spanCount ?? existing.callCount ?? 0) + 1;
     const newErrorCount = (existing.signal?.errorCount ?? 0) + (isError ? 1 : 0);
+    const latencyHist2 = durationMs !== void 0 ? recordLatency({ ...existing.signal?.latencyHist ?? {} }, durationMs) : existing.signal?.latencyHist;
+    const latencyMs2 = latencyPercentiles(latencyHist2) ?? existing.signal?.latencyMs;
     const newSignal = {
       spanCount: newSpanCount,
       errorCount: newErrorCount,
-      lastObservedAgeMs: 0
+      lastObservedAgeMs: 0,
+      ...latencyHist2 ? { latencyHist: latencyHist2 } : {},
+      ...latencyMs2 ? { latencyMs: latencyMs2 } : {},
+      ...existing.signal?.anomalous !== void 0 ? { anomalous: existing.signal.anomalous } : {}
     };
     const updated = {
       ...existing,
@@ -4060,10 +4123,14 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     graph.replaceEdgeAttributes(id, updated);
     return { edge: updated, created: false };
   }
+  const latencyHist = durationMs !== void 0 ? recordLatency({}, durationMs) : void 0;
+  const latencyMs = latencyHist ? latencyPercentiles(latencyHist) : void 0;
   const signal = {
     spanCount: 1,
     errorCount: isError ? 1 : 0,
-    lastObservedAgeMs: 0
+    lastObservedAgeMs: 0,
+    ...latencyHist ? { latencyHist } : {},
+    ...latencyMs ? { latencyMs } : {}
   };
   const edge = {
     id,
@@ -4127,6 +4194,21 @@ async function appendErrorEvent(ctx, ev) {
   await fs7.mkdir(path8.dirname(ctx.errorsPath), { recursive: true });
   await fs7.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
+async function appendConnectorIncident(errorsPath, input) {
+  const ev = {
+    id: input.id,
+    timestamp: input.timestamp,
+    service: input.service,
+    traceId: input.id,
+    spanId: input.id,
+    errorType: input.errorType,
+    errorMessage: input.errorMessage,
+    ...input.attributes && Object.keys(input.attributes).length > 0 ? { attributes: input.attributes } : {},
+    affectedNode: input.affectedNode
+  };
+  await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
+  await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+}
 function incidentAffectedNode(span, graph, scanPath) {
   const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : serviceId(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
@@ -4273,6 +4355,7 @@ async function handleSpan(ctx, span) {
   }
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = span.statusCode === 2;
+  const durationMs = span.durationNanos > 0n ? Number(span.durationNanos) / 1e6 : void 0;
   const sourceServiceNode = ctx.graph.getNodeAttributes(sourceId);
   const callSite = callSiteFromSpan(span, sourceServiceNode, ctx.scanPath);
   cacheSpanService(span, nowMs, callSite);
@@ -4311,7 +4394,8 @@ async function handleSpan(ctx, span) {
         targetId,
         ts,
         isError,
-        callSiteEvidence
+        callSiteEvidence,
+        durationMs
       );
       if (result) affectedNode = targetId;
       if (span.dbSystem === "mongodb" && span.dbCollection) {
@@ -4323,7 +4407,8 @@ async function handleSpan(ctx, span) {
           collectionId,
           ts,
           isError,
-          callSiteEvidence
+          callSiteEvidence,
+          durationMs
         );
       }
       if (span.dbTable) {
@@ -4335,7 +4420,8 @@ async function handleSpan(ctx, span) {
           tableId,
           ts,
           isError,
-          callSiteEvidence
+          callSiteEvidence,
+          durationMs
         );
         mergeObservedColumns(ctx.graph, tableId, span.dbColumns);
       }
@@ -4354,7 +4440,8 @@ async function handleSpan(ctx, span) {
       targetId,
       ts,
       isError,
-      callSiteEvidence
+      callSiteEvidence,
+      durationMs
     );
     if (result) affectedNode = targetId;
   } else if (span.graphqlOperationName && span.graphqlOperationType && spanServesGraphqlOperation(span.kind)) {
@@ -4371,7 +4458,8 @@ async function handleSpan(ctx, span) {
       targetId,
       ts,
       isError,
-      callSiteEvidence
+      callSiteEvidence,
+      durationMs
     );
     if (result) affectedNode = targetId;
   } else if (span.rpcSystem === "grpc" && span.rpcService && span.rpcMethod && spanServesGrpcMethod(span.kind)) {
@@ -4383,7 +4471,8 @@ async function handleSpan(ctx, span) {
       targetId,
       ts,
       isError,
-      callSiteEvidence
+      callSiteEvidence,
+      durationMs
     );
     if (result) affectedNode = targetId;
   } else if (span.websocketChannel && spanServesWebsocketChannel(span.kind)) {
@@ -4399,7 +4488,8 @@ async function handleSpan(ctx, span) {
       targetId,
       ts,
       isError,
-      callSiteEvidence
+      callSiteEvidence,
+      durationMs
     );
     if (result) affectedNode = targetId;
   } else {
@@ -4415,7 +4505,8 @@ async function handleSpan(ctx, span) {
           targetId,
           ts,
           isError,
-          callSiteEvidence
+          callSiteEvidence,
+          durationMs
         );
         affectedNode = targetId;
         resolvedViaAddress = true;
@@ -4428,7 +4519,8 @@ async function handleSpan(ctx, span) {
           frontierNodeId,
           ts,
           isError,
-          callSiteEvidence
+          callSiteEvidence,
+          durationMs
         );
         affectedNode = frontierNodeId;
         resolvedViaAddress = true;
@@ -4454,7 +4546,8 @@ async function handleSpan(ctx, span) {
           sourceId,
           ts,
           isError,
-          fallbackEvidence
+          fallbackEvidence,
+          durationMs
         );
       }
     }
@@ -4468,7 +4561,7 @@ async function handleSpan(ctx, span) {
     );
     if (routeNodeId) {
       const routeSvc = ctx.graph.getNodeAttributes(routeNodeId).service;
-      upsertObservedEdge(ctx.graph, EdgeType5.CONTAINS, serviceId(routeSvc), routeNodeId, ts, isError);
+      upsertObservedEdge(ctx.graph, EdgeType5.CONTAINS, serviceId(routeSvc), routeNodeId, ts, isError, void 0, durationMs);
     }
   }
   if (span.statusCode === 2) {
@@ -4757,10 +4850,12 @@ function mergeSnapshot(graph, snapshot) {
 import {
   BlastRadiusResultSchema,
   EdgeType as EdgeType6,
+  ExpandResultSchema,
   NodeType as NodeType5,
   ObservedDependenciesResultSchema,
   PROV_RANK,
   Provenance as Provenance6,
+  RelateResultSchema,
   RootCauseResultSchema,
   TransitiveDependenciesResultSchema
 } from "@neat.is/types";
@@ -4977,7 +5072,7 @@ var rootCauseShapes = {
   [NodeType5.FileNode]: fileRootCauseShape,
   [NodeType5.SymbolNode]: symbolRootCauseShape
 };
-function getRootCause(graph, errorNodeId, errorEvent, incidents) {
+function legacyRootCause(graph, errorNodeId, errorEvent, incidents) {
   if (!graph.hasNode(errorNodeId)) return null;
   const origin = graph.getNodeAttributes(errorNodeId);
   const shape = rootCauseShapes[origin.type];
@@ -5234,7 +5329,9 @@ function getObservedDependencies(graph, nodeId) {
       dependencies: [],
       observed: false,
       inboundObservedCount: 0,
-      hasExtractedOutbound: false
+      hasExtractedOutbound: false,
+      inboundVolume: 0,
+      window: "lifetime"
     });
   }
   const attrs = graph.getNodeAttributes(nodeId);
@@ -5265,11 +5362,19 @@ function getObservedDependencies(graph, nodeId) {
     }
   }
   let inboundObservedCount = 0;
+  let inboundVolume = 0;
+  let inboundLastObserved;
   for (const tgt of scope) {
     for (const edgeId of graph.inboundEdges(tgt)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (e.type === EdgeType6.CONTAINS) continue;
-      if (e.provenance === Provenance6.OBSERVED) inboundObservedCount += 1;
+      if (e.provenance === Provenance6.OBSERVED) {
+        inboundObservedCount += 1;
+        inboundVolume += e.callCount ?? e.signal?.spanCount ?? 1;
+        if (e.lastObserved && (!inboundLastObserved || e.lastObserved > inboundLastObserved)) {
+          inboundLastObserved = e.lastObserved;
+        }
+      }
     }
   }
   dependencies.sort(
@@ -5280,7 +5385,291 @@ function getObservedDependencies(graph, nodeId) {
     dependencies,
     observed: dependencies.length > 0 || inboundObservedCount > 0,
     inboundObservedCount,
-    hasExtractedOutbound
+    hasExtractedOutbound,
+    // The signal is cumulative, so the honest window label is "lifetime" (ADR-190).
+    inboundVolume,
+    window: "lifetime",
+    ...inboundLastObserved ? { inboundLastObserved } : {}
+  });
+}
+var SATURATION_P95_MS = 1e3;
+function nodeScope(graph, nodeId) {
+  const scope = [nodeId];
+  if (!graph.hasNode(nodeId)) return scope;
+  const attrs = graph.getNodeAttributes(nodeId);
+  if (attrs.type === NodeType5.ServiceNode) {
+    for (const edgeId of graph.outboundEdges(nodeId)) {
+      const e = graph.getEdgeAttributes(edgeId);
+      if (e.type !== EdgeType6.CONTAINS) continue;
+      const owned = graph.getNodeAttributes(e.target);
+      if (owned.type === NodeType5.FileNode) scope.push(e.target);
+    }
+  }
+  return scope;
+}
+function incidentCountForNode(nodeId, incidents) {
+  if (!incidents || incidents.length === 0) return 0;
+  return incidents.filter((ev) => incidentMatchesNode(ev, nodeId)).length;
+}
+function nodeContext(graph, nodeId, incidents, now = Date.now()) {
+  const scope = nodeScope(graph, nodeId);
+  let errorsFromCallers = 0;
+  let inboundVolume = 0;
+  let outboundVolume = 0;
+  let outboundErrors = 0;
+  let latestInboundMs;
+  let latencyP95Ms;
+  let stale = false;
+  for (const n of scope) {
+    if (!graph.hasNode(n)) continue;
+    for (const edgeId of graph.inboundEdges(n)) {
+      const e = graph.getEdgeAttributes(edgeId);
+      if (e.type === EdgeType6.CONTAINS) continue;
+      errorsFromCallers += e.signal?.errorCount ?? 0;
+      inboundVolume += e.callCount ?? e.signal?.spanCount ?? 0;
+      if (e.provenance === Provenance6.STALE) stale = true;
+      const p95 = e.signal?.latencyMs?.p95;
+      if (p95 !== void 0) latencyP95Ms = Math.max(latencyP95Ms ?? 0, p95);
+      if (e.lastObserved) {
+        const t = Date.parse(e.lastObserved);
+        if (Number.isFinite(t)) latestInboundMs = Math.max(latestInboundMs ?? 0, t);
+      }
+    }
+    for (const edgeId of graph.outboundEdges(n)) {
+      const e = graph.getEdgeAttributes(edgeId);
+      if (e.type === EdgeType6.CONTAINS) continue;
+      outboundVolume += e.callCount ?? e.signal?.spanCount ?? 0;
+      if (e.type === EdgeType6.CALLS) outboundErrors += e.signal?.errorCount ?? 0;
+      if (e.provenance === Provenance6.STALE) stale = true;
+    }
+  }
+  const errorsEmittedHere = incidentCountForNode(nodeId, incidents) + outboundErrors;
+  const lastObservedAgeMs = latestInboundMs !== void 0 ? Math.max(0, now - latestInboundMs) : void 0;
+  return {
+    errorsEmittedHere,
+    errorsFromCallers,
+    callCount: inboundVolume,
+    outboundVolume,
+    ...lastObservedAgeMs !== void 0 ? { lastObservedAgeMs } : {},
+    ...latencyP95Ms !== void 0 ? { latencyP95Ms } : {},
+    stale
+  };
+}
+function isSaturated(ctx) {
+  return ctx.latencyP95Ms !== void 0 && ctx.latencyP95Ms >= SATURATION_P95_MS;
+}
+function classifyNode(ctx) {
+  if (ctx.errorsEmittedHere > 0) {
+    if ((ctx.stale || isSaturated(ctx)) && ctx.errorsFromCallers >= ctx.errorsEmittedHere) {
+      return "symptom-only";
+    }
+    return "primary-failure";
+  }
+  if (ctx.errorsFromCallers > 0) return "symptom-only";
+  return "unrelated";
+}
+function isVictimSeed(ctx) {
+  return ctx.errorsFromCallers > 0 && (ctx.stale || isSaturated(ctx)) && ctx.errorsEmittedHere <= ctx.errorsFromCallers;
+}
+function grainOf(graph, nodeId) {
+  if (!graph.hasNode(nodeId)) return "unknown";
+  const t = graph.getNodeAttributes(nodeId).type;
+  if (t === NodeType5.ServiceNode) return "service";
+  if (t === NodeType5.FileNode) return "file";
+  if (t === NodeType5.SymbolNode) return "symbol";
+  return t;
+}
+function findPath(graph, from, to, direction, maxDepth) {
+  if (!graph.hasNode(from) || !graph.hasNode(to)) return null;
+  if (from === to) return { nodes: [from], edges: [] };
+  const queue = [{ nodeId: from, depth: 0, nodes: [from], edges: [] }];
+  const enqueued = /* @__PURE__ */ new Set([from]);
+  while (queue.length > 0) {
+    const frame = queue.shift();
+    if (frame.depth >= maxDepth) continue;
+    const best = direction === "up" ? bestEdgeBySource(graph, graph.inboundEdges(frame.nodeId)) : bestEdgeByTarget(graph, graph.outboundEdges(frame.nodeId));
+    const neighbours = [...best.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [nid, edge] of neighbours) {
+      if (nid === to) return { nodes: [...frame.nodes, nid], edges: [...frame.edges, edge] };
+      if (enqueued.has(nid)) continue;
+      enqueued.add(nid);
+      queue.push({
+        nodeId: nid,
+        depth: frame.depth + 1,
+        nodes: [...frame.nodes, nid],
+        edges: [...frame.edges, edge]
+      });
+    }
+  }
+  return null;
+}
+var EMPTY_CONTEXT = {
+  errorsEmittedHere: 0,
+  errorsFromCallers: 0,
+  callCount: 0,
+  outboundVolume: 0,
+  stale: false
+};
+function expandNode(graph, nodeId, direction, incidents, now = Date.now()) {
+  if (!graph.hasNode(nodeId)) {
+    return ExpandResultSchema.parse({
+      origin: nodeId,
+      direction,
+      node: { id: nodeId, classification: "unrelated", context: EMPTY_CONTEXT },
+      neighbours: []
+    });
+  }
+  const ctx = nodeContext(graph, nodeId, incidents, 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 === EdgeType6.CONTAINS) continue;
+    const nctx = nodeContext(graph, nid, incidents, now);
+    neighbours.push({
+      node: nid,
+      edgeType: edge.type,
+      provenance: edge.provenance,
+      classification: classifyNode(nctx),
+      context: nctx
+    });
+  }
+  neighbours.sort((a, b) => a.node.localeCompare(b.node));
+  return ExpandResultSchema.parse({
+    origin: nodeId,
+    direction,
+    node: { id: nodeId, classification: classifyNode(ctx), context: ctx },
+    neighbours
+  });
+}
+function relate(graph, a, b, maxDepth = ROOT_CAUSE_MAX_DEPTH) {
+  const buildPath = (fp) => ({
+    nodes: fp.nodes,
+    edgeTypes: fp.edges.map((e) => e.type),
+    provenance: fp.edges.map((e) => e.provenance),
+    grain: fp.nodes.map((n) => grainOf(graph, n)),
+    // The failure runs end to end when every hop carries error / latency / alert
+    // signal — that is what turns reachability into cause-confirmation.
+    carriesSignal: fp.edges.length > 0 && fp.edges.every(
+      (e) => (e.signal?.errorCount ?? 0) > 0 || e.signal?.latencyMs !== void 0 || e.signal?.anomalous !== void 0
+    )
+  });
+  if (!graph.hasNode(a) || !graph.hasNode(b)) {
+    return RelateResultSchema.parse({
+      a,
+      b,
+      related: false,
+      direction: null,
+      paths: [],
+      note: !graph.hasNode(a) ? `node not found: ${a}` : `node not found: ${b}`
+    });
+  }
+  const down = findPath(graph, a, b, "down", maxDepth);
+  const up = findPath(graph, a, b, "up", maxDepth);
+  if (!down && !up) {
+    return RelateResultSchema.parse({
+      a,
+      b,
+      related: false,
+      direction: null,
+      paths: [],
+      note: `no path within ${maxDepth} hops`
+    });
+  }
+  const paths = [];
+  const direction = down ? "a->b" : "b->a";
+  if (down) paths.push(buildPath(down));
+  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 RelateResultSchema.parse({
+    a,
+    b,
+    related: true,
+    direction,
+    paths,
+    ...grainGap ? { grainGap: true } : {}
+  });
+}
+function findLoadOrigin(graph, alertNodeId, incidents, now) {
+  const upstream = getBlastRadius(graph, alertNodeId).affectedNodes.map((n) => n.nodeId);
+  let best = null;
+  for (const nid of upstream) {
+    if (nid === alertNodeId) continue;
+    const ctx = nodeContext(graph, nid, incidents, now);
+    if (ctx.outboundVolume === 0) continue;
+    const isSource = ctx.callCount === 0;
+    const better = !best || (isSource !== best.isSource ? isSource : ctx.outboundVolume !== best.ctx.outboundVolume ? ctx.outboundVolume > best.ctx.outboundVolume : nid < best.node);
+    if (better) best = { node: nid, ctx, isSource };
+  }
+  return best ? { node: best.node, ctx: best.ctx } : null;
+}
+function getRootCause(graph, errorNodeId, errorEvent, incidents, opts) {
+  const legacy = legacyRootCause(graph, errorNodeId, errorEvent, incidents);
+  if (!legacy) return null;
+  const navigation = opts?.navigation ?? process.env.NEAT_RCA_NAVIGATION !== "0";
+  if (!navigation) return legacy;
+  return enrichWithNavigation(graph, errorNodeId, legacy, incidents, opts?.now ?? Date.now());
+}
+function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
+  const seedNode = legacy.rootCauseNode;
+  const seedCtx = graph.hasNode(seedNode) ? nodeContext(graph, seedNode, incidents, now) : null;
+  const lastProv = legacy.edgeProvenances[legacy.edgeProvenances.length - 1];
+  const candidates = [];
+  if (seedCtx && isVictimSeed(seedCtx)) {
+    const origin = findLoadOrigin(graph, errorNodeId, incidents, now);
+    if (origin) {
+      const path64 = findPath(graph, errorNodeId, origin.node, "up", ROOT_CAUSE_MAX_DEPTH);
+      const originConfidence = confidenceFromMix(path64?.edges ?? [], now);
+      candidates.push({
+        node: origin.node,
+        classification: "primary-failure",
+        reason: `Highest-volume upstream source (${origin.ctx.outboundVolume} observed outbound calls) driving a saturated/stale subgraph; the alerting path decays downstream into a starved victim rather than a fault at the callee.`,
+        context: origin.ctx,
+        confidence: Math.max(0.3, Math.min(0.8, originConfidence || 0.5)),
+        provenance: Provenance6.OBSERVED
+      });
+    }
+    const staleNote = seedCtx.stale ? "; the node has gone STALE" : "";
+    const satNote = isSaturated(seedCtx) ? `; inbound p95 ${Math.round(seedCtx.latencyP95Ms)}ms is saturated` : "";
+    candidates.push({
+      node: seedNode,
+      classification: "symptom-only",
+      reason: `Errors arrive from callers (${seedCtx.errorsFromCallers}) but none originate here${staleNote}${satNote} \u2014 a downstream victim of load, not the fault.`,
+      context: seedCtx,
+      confidence: Math.min(legacy.confidence, 0.4),
+      ...lastProv ? { provenance: lastProv } : {}
+    });
+  } else {
+    candidates.push({
+      node: seedNode,
+      classification: "primary-failure",
+      reason: legacy.rootCauseReason,
+      context: seedCtx ?? EMPTY_CONTEXT,
+      confidence: legacy.confidence,
+      ...lastProv ? { provenance: lastProv } : {}
+    });
+  }
+  const top = candidates[0];
+  let traversalPath = legacy.traversalPath;
+  let edgeProvenances = legacy.edgeProvenances;
+  if (top.node !== seedNode) {
+    const path64 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path64) {
+      traversalPath = path64.nodes;
+      edgeProvenances = path64.edges.map((e) => e.provenance);
+    } else {
+      traversalPath = [errorNodeId, top.node];
+      edgeProvenances = [top.provenance ?? Provenance6.OBSERVED];
+    }
+  }
+  return RootCauseResultSchema.parse({
+    rootCauseNode: top.node,
+    rootCauseReason: top.reason,
+    traversalPath,
+    edgeProvenances,
+    confidence: top.confidence,
+    ...legacy.fixRecommendation ? { fixRecommendation: legacy.fixRecommendation } : {},
+    candidates
   });
 }
 
@@ -10488,8 +10877,41 @@ import path45 from "path";
 import Parser14 from "tree-sitter";
 import Go3 from "tree-sitter-go";
 import { infraId as infraId15 } from "@neat.is/types";
-var SQL_METHODS = /* @__PURE__ */ new Set(["Exec", "ExecContext", "Query", "QueryContext", "QueryRow", "QueryRowContext"]);
 var PARSE_CHUNK10 = 16384;
+var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
+  "Query",
+  "QueryContext",
+  "QueryRow",
+  "QueryRowContext",
+  "Exec",
+  "ExecContext",
+  "Prepare",
+  "PrepareContext"
+]);
+var SQLX_METHODS = /* @__PURE__ */ new Set([
+  "Get",
+  "Select",
+  "Queryx",
+  "QueryRowx",
+  "NamedExec",
+  "NamedQuery",
+  "MustExec",
+  "Preparex",
+  "GetContext",
+  "SelectContext"
+]);
+var DATABASE_SQL_IMPORT = "database/sql";
+var SQLX_IMPORT = "github.com/jmoiron/sqlx";
+function makeGoParser3() {
+  const p = new Parser14();
+  p.setLanguage(Go3);
+  return p;
+}
+function parseSource10(parser, source) {
+  return parser.parse(
+    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK10)
+  );
+}
 function walk7(node, visit) {
   visit(node);
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -10497,25 +10919,54 @@ function walk7(node, visit) {
     if (child) walk7(child, visit);
   }
 }
+function goStringLiteralValue(node) {
+  if (!node) return null;
+  if (node.type === "interpreted_string_literal" || node.type === "raw_string_literal") {
+    const t = node.text;
+    return t.length >= 2 ? t.slice(1, -1) : "";
+  }
+  return null;
+}
+function goImportsAny(root, names) {
+  let found = false;
+  walk7(root, (node) => {
+    if (found || node.type !== "import_spec") return;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const value = goStringLiteralValue(node.namedChild(i));
+      if (value !== null && names.has(value)) found = true;
+    }
+  });
+  return found;
+}
+function firstStringLiteralArg(argsNode) {
+  if (!argsNode) return null;
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const value = goStringLiteralValue(argsNode.namedChild(i));
+    if (value !== null) return value;
+  }
+  return null;
+}
 function goSqlEndpointsFromFile(file, serviceDir) {
   if (path45.extname(file.path) !== ".go") return [];
-  const parser = new Parser14();
-  parser.setLanguage(Go3);
-  const tree = parser.parse(
-    (index) => index >= file.content.length ? "" : file.content.slice(index, index + PARSE_CHUNK10)
-  );
+  if (!file.content.includes(DATABASE_SQL_IMPORT) && !file.content.includes(SQLX_IMPORT)) return [];
+  const tree = parseSource10(makeGoParser3(), file.content);
+  const importsDatabaseSql = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([DATABASE_SQL_IMPORT]));
+  const importsSqlx = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([SQLX_IMPORT]));
+  if (!importsDatabaseSql && !importsSqlx) return [];
   const out = [];
   walk7(tree.rootNode, (node) => {
     if (node.type !== "call_expression") return;
     const fn = node.childForFieldName("function");
     if (fn?.type !== "selector_expression") return;
     const method = fn.childForFieldName("field")?.text;
-    if (!method || !SQL_METHODS.has(method)) return;
-    const arg = node.childForFieldName("arguments")?.namedChild(0);
-    if (!arg || arg.type !== "interpreted_string_literal" && arg.type !== "raw_string_literal") return;
-    const sql = arg.text.slice(1, -1);
+    if (!method) return;
+    const recognized = DATABASE_SQL_METHODS.has(method) || importsSqlx && SQLX_METHODS.has(method);
+    if (!recognized) return;
+    const sql = firstStringLiteralArg(node.childForFieldName("arguments"));
+    if (sql === null) return;
     const table = tableFromSqlStatement(sql);
     if (!table) return;
+    const columns = columnsFromSqlStatement(sql);
     const line = node.startPosition.row + 1;
     out.push({
       infraId: infraId15("sql-table", table),
@@ -10523,7 +10974,12 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: toPosix(path45.relative(serviceDir, file.path)), line, snippet: snippet(file.content, line) }
+      ...columns.length > 0 ? { columns } : {},
+      evidence: {
+        file: toPosix(path45.relative(serviceDir, file.path)),
+        line,
+        snippet: snippet(file.content, line)
+      }
     });
   });
   return out;
@@ -10536,12 +10992,12 @@ import Go4 from "tree-sitter-go";
 import { infraId as infraId16 } from "@neat.is/types";
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK11 = 16384;
-function makeGoParser3() {
+function makeGoParser4() {
   const p = new Parser15();
   p.setLanguage(Go4);
   return p;
 }
-function parseSource10(parser, source) {
+function parseSource11(parser, source) {
   return parser.parse(
     (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK11)
   );
@@ -10965,7 +11421,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
 function gormEndpointsFromFile(file, serviceDir) {
   if (path46.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource10(makeGoParser3(), file.content);
+  const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
   const out = [];
   const seenTables = /* @__PURE__ */ new Set();
@@ -10996,7 +11452,7 @@ function gormEndpointsFromFile(file, serviceDir) {
 function gormForeignKeys(file, serviceDir) {
   if (path46.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource10(makeGoParser3(), file.content);
+  const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -14420,6 +14876,23 @@ async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
       unresolved++;
       continue;
     }
+    if (signal.incident) {
+      ensureServiceNode(graph, resolved.serviceName, NO_ENV);
+      if (!ctx.errorsPath || !graph.hasNode(resolved.targetNodeId)) {
+        unresolved++;
+        continue;
+      }
+      await appendConnectorIncident(ctx.errorsPath, {
+        id: signal.incident.id,
+        timestamp: signal.incident.timestamp,
+        service: signal.incident.service,
+        errorType: signal.incident.errorType,
+        errorMessage: signal.incident.errorMessage,
+        ...signal.incident.attributes ? { attributes: signal.incident.attributes } : {},
+        affectedNode: resolved.targetNodeId
+      });
+      continue;
+    }
     if (resolved.ensureInfraNode) {
       const { kind, name, provider } = resolved.ensureInfraNode;
       ensureInfraNode(graph, kind, name, provider);
@@ -16587,6 +17060,329 @@ function createPlanetscaleConnector(graph, config, deps = {}) {
   };
 }
 
+// src/connectors/eas/types.ts
+function readEasCredentials(raw) {
+  const token = raw["token"];
+  if (typeof token !== "string" || token.length === 0) {
+    throw new Error("eas connector: credentials.token (EXPO_TOKEN) must be a non-empty string");
+  }
+  return { token };
+}
+var EAS_STATUS_ERRORED = "ERRORED";
+var TRANSIENT_BUILD_PHASES = /* @__PURE__ */ new Set([
+  "SPIN_UP_BUILDER",
+  "PREPARE_CREDENTIALS",
+  "RESTORE_CACHE",
+  "UPLOAD_APPLICATION_ARCHIVE"
+]);
+var INTERNAL_ERROR_CODE = /INTERNAL_SERVER_ERROR|EAS_BUILD_.*INTERNAL|_INTERNAL_ERROR|UNKNOWN_ERROR/i;
+function isTransientFailure(err) {
+  if (!err) return false;
+  const phase = typeof err.buildPhase === "string" ? err.buildPhase : void 0;
+  if (phase) {
+    if (TRANSIENT_BUILD_PHASES.has(phase)) return true;
+    if (/^SPIN_UP|_CREDENTIALS$|^RESTORE_CACHE/i.test(phase)) return true;
+  }
+  const code = typeof err.errorCode === "string" ? err.errorCode : void 0;
+  if (code && INTERNAL_ERROR_CODE.test(code)) return true;
+  return false;
+}
+var FIELD_SEP3 = "\0";
+var EAS_TARGET_KIND = "eas-build";
+function packEasTargetName(identity) {
+  return [identity.serviceName, identity.phase].join(FIELD_SEP3);
+}
+function parseEasTargetName(targetName) {
+  const sep = targetName.indexOf(FIELD_SEP3);
+  if (sep === -1) return null;
+  const serviceName = targetName.slice(0, sep);
+  const phase = targetName.slice(sep + 1);
+  if (!serviceName) return null;
+  return { serviceName, phase };
+}
+
+// src/connectors/eas/client.ts
+var DEFAULT_EAS_API_URL = "https://api.expo.dev/graphql";
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_MAX_PAGES = 10;
+var DEFAULT_MAX_LOG_BYTES = 16 * 1024;
+var DEFAULT_MAX_LOOKBACK_MS6 = 7 * 24 * 60 * 60 * 1e3;
+var BUILDS_QUERY = `
+  query NeatEasErroredBuilds($appId: String!, $offset: Int!, $limit: Int!) {
+    app {
+      byId(appId: $appId) {
+        builds(offset: $offset, limit: $limit, filter: { status: ERRORED }) {
+          id
+          status
+          platform
+          buildProfile
+          gitCommitHash
+          gitCommitMessage
+          gitRef
+          isGitWorkingTreeDirty
+          createdAt
+          completedAt
+          error {
+            buildPhase
+            errorCode
+            message
+            docsUrl
+          }
+          logFileUrls
+        }
+      }
+    }
+  }
+`;
+async function easGraphQL(apiUrl, token, query, variables, accountKey, fetchImpl) {
+  const res = await junctionFetch(
+    apiUrl,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...bearerAuthHeader(token)
+      },
+      body: JSON.stringify({ query, variables })
+    },
+    // accountKey: the Expo app id — the per-(provider, accountKey) rate-limit
+    // bucket (ADR-131), the closest thing this connector carries to "one account".
+    { provider: "eas", accountKey, ...fetchImpl ? { fetchImpl } : {} }
+  );
+  if (!res.ok) {
+    throw new Error(`Expo GraphQL request failed: ${res.status} ${res.statusText}`);
+  }
+  const body = await res.json();
+  if (body.errors && body.errors.length > 0) {
+    throw new Error(`Expo GraphQL errors: ${body.errors.map((e) => e.message).join("; ")}`);
+  }
+  if (!body.data) throw new Error("Expo GraphQL response carried no data");
+  return body.data;
+}
+async function fetchErroredBuilds(token, config, fetchImpl) {
+  const apiUrl = config.apiUrl ?? DEFAULT_EAS_API_URL;
+  const pageSize = config.pageSize ?? DEFAULT_PAGE_SIZE;
+  const maxPages = config.maxPages ?? DEFAULT_MAX_PAGES;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let page = 0; page < maxPages; page++) {
+    const data = await easGraphQL(
+      apiUrl,
+      token,
+      BUILDS_QUERY,
+      { appId: config.appId, offset: page * pageSize, limit: pageSize },
+      config.appId,
+      fetchImpl
+    );
+    const builds = data.app?.byId?.builds;
+    if (!Array.isArray(builds)) break;
+    let added = 0;
+    for (const b of builds) {
+      if (!b || typeof b.id !== "string" || b.id.length === 0) continue;
+      if (b.status !== EAS_STATUS_ERRORED) continue;
+      if (seen.has(b.id)) continue;
+      seen.add(b.id);
+      out.push(b);
+      added++;
+    }
+    if (builds.length < pageSize) break;
+    if (added === 0) break;
+  }
+  return out;
+}
+async function fetchBuildLogs(logFileUrls, maxBytes = DEFAULT_MAX_LOG_BYTES, fetchImpl) {
+  if (!Array.isArray(logFileUrls) || logFileUrls.length === 0) return "";
+  const doFetch = fetchImpl ?? fetch;
+  const chunks = [];
+  for (const url of logFileUrls) {
+    if (typeof url !== "string" || url.length === 0) continue;
+    try {
+      const res = await doFetch(url);
+      if (!res.ok) continue;
+      chunks.push(await res.text());
+    } catch {
+    }
+  }
+  const joined = chunks.join("\n");
+  return joined.length > maxBytes ? joined.slice(joined.length - maxBytes) : joined;
+}
+
+// src/connectors/eas/map.ts
+function buildEventTime(build) {
+  if (typeof build.completedAt === "string" && build.completedAt.length > 0) return build.completedAt;
+  if (typeof build.createdAt === "string" && build.createdAt.length > 0) return build.createdAt;
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function incidentMessage2(build) {
+  const err = build.error ?? {};
+  const phase = typeof err.buildPhase === "string" && err.buildPhase.length > 0 ? ` at ${err.buildPhase}` : "";
+  const detail = typeof err.message === "string" && err.message.trim().length > 0 && err.message.trim() || typeof err.errorCode === "string" && err.errorCode.length > 0 && err.errorCode || "no error detail reported";
+  let msg = `EAS build failed${phase}: ${detail}`;
+  if (build.isGitWorkingTreeDirty === true) {
+    msg += " (built from a dirty working tree \u2014 the commit may not represent what built)";
+  }
+  return msg;
+}
+function incidentAttributes(build) {
+  const attrs = {};
+  const err = build.error ?? {};
+  const put = (k, v) => {
+    if (typeof v === "string" && v.length === 0) return;
+    if (v !== void 0 && v !== null) attrs[k] = v;
+  };
+  put("eas.buildId", build.id);
+  put("eas.platform", build.platform ?? void 0);
+  put("eas.buildProfile", build.buildProfile ?? void 0);
+  put("eas.buildPhase", err.buildPhase ?? void 0);
+  put("eas.errorCode", err.errorCode ?? void 0);
+  put("eas.docsUrl", err.docsUrl ?? void 0);
+  put("eas.gitCommitHash", build.gitCommitHash ?? void 0);
+  put("eas.gitRef", build.gitRef ?? void 0);
+  put("eas.gitCommitMessage", build.gitCommitMessage ?? void 0);
+  if (typeof build.isGitWorkingTreeDirty === "boolean") {
+    attrs["eas.gitWorkingTreeDirty"] = build.isGitWorkingTreeDirty;
+    if (build.isGitWorkingTreeDirty) attrs["eas.confidence"] = "low";
+  }
+  put("eas.createdAt", build.createdAt ?? void 0);
+  put("eas.completedAt", build.completedAt ?? void 0);
+  if (typeof build.logsText === "string" && build.logsText.length > 0) {
+    attrs["eas.logs"] = build.logsText;
+  }
+  return attrs;
+}
+function mapBuildToSignal(build, serviceName) {
+  if (!build || typeof build !== "object") return null;
+  if (build.status !== EAS_STATUS_ERRORED) return null;
+  if (!build.error) return null;
+  if (isTransientFailure(build.error)) return null;
+  const timestamp = buildEventTime(build);
+  const phase = typeof build.error.buildPhase === "string" ? build.error.buildPhase : "";
+  return {
+    targetKind: EAS_TARGET_KIND,
+    targetName: packEasTargetName({ serviceName, phase }),
+    // Incident-only — no edge, so no call/error count to replay.
+    callCount: 0,
+    errorCount: 0,
+    lastObservedIso: timestamp,
+    incident: {
+      id: `eas:build:${build.id}`,
+      timestamp,
+      service: serviceName,
+      errorType: "eas-build-failure",
+      errorMessage: incidentMessage2(build),
+      attributes: incidentAttributes(build)
+    }
+  };
+}
+function mapBuildsToSignals(builds, serviceName) {
+  const out = [];
+  for (const build of builds) {
+    const signal = mapBuildToSignal(build, serviceName);
+    if (signal) out.push(signal);
+  }
+  return out;
+}
+
+// src/connectors/eas/resolve.ts
+import { EdgeType as EdgeType34, NodeType as NodeType32, parseFileId as parseFileId3 } from "@neat.is/types";
+var NO_ENV2 = "unknown";
+var EAS_JSON_PHASES = /* @__PURE__ */ new Set(["READ_EAS_JSON"]);
+var APP_CONFIG_PHASES = /* @__PURE__ */ new Set([
+  "READ_APP_CONFIG",
+  "CONFIGURE_EXPO_UPDATES",
+  "CALCULATE_EXPO_UPDATES_RUNTIME_VERSION"
+]);
+function configBasenamesForPhase(phase) {
+  if (EAS_JSON_PHASES.has(phase)) return ["eas.json"];
+  if (APP_CONFIG_PHASES.has(phase)) return ["app.json", "app.config.json"];
+  return [];
+}
+function configNodeService(graph, configNodeId) {
+  for (const edgeId of graph.inboundEdges(configNodeId)) {
+    const edge = graph.getEdgeAttributes(edgeId);
+    if (edge.type !== EdgeType34.CONFIGURED_BY) continue;
+    const parsed = parseFileId3(edge.source);
+    if (parsed) return parsed.service;
+  }
+  return null;
+}
+function findConfigNode(graph, basenames, serviceName) {
+  let scoped = null;
+  let anyMatch = null;
+  graph.forEachNode((id, attrs) => {
+    if (scoped) return;
+    const node = attrs;
+    if (node.type !== NodeType32.ConfigNode) return;
+    if (typeof node.name !== "string" || !basenames.includes(node.name)) return;
+    if (anyMatch === null) anyMatch = id;
+    if (configNodeService(graph, id) === serviceName) scoped = id;
+  });
+  return scoped ?? anyMatch;
+}
+function createEasResolveTarget(graph) {
+  return (signal) => {
+    if (signal.targetKind !== EAS_TARGET_KIND) return null;
+    const identity = parseEasTargetName(signal.targetName);
+    if (!identity) return null;
+    const { serviceName, phase } = identity;
+    const basenames = configBasenamesForPhase(phase);
+    if (basenames.length > 0) {
+      const configNodeId = findConfigNode(graph, basenames, serviceName);
+      if (configNodeId) {
+        return { targetNodeId: configNodeId, serviceName, edgeType: EdgeType34.CALLS };
+      }
+    }
+    return {
+      targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
+      serviceName,
+      edgeType: EdgeType34.CALLS
+    };
+  };
+}
+
+// src/connectors/eas/index.ts
+function isBuildSince(build, sinceIso) {
+  const t = Date.parse(buildEventTime(build));
+  const s = Date.parse(sinceIso);
+  if (Number.isNaN(t) || Number.isNaN(s)) return true;
+  return t > s;
+}
+function boundedSinceIso2(since, now, maxLookbackMs) {
+  const floor = new Date(now.getTime() - maxLookbackMs);
+  if (!since) return floor.toISOString();
+  const sinceMs = new Date(since).getTime();
+  if (Number.isNaN(sinceMs)) return floor.toISOString();
+  return sinceMs < floor.getTime() ? floor.toISOString() : new Date(sinceMs).toISOString();
+}
+var EasConnector = class {
+  constructor(config, fetchImpl) {
+    this.config = config;
+    this.fetchImpl = fetchImpl;
+  }
+  config;
+  fetchImpl;
+  provider = "eas";
+  async poll(ctx) {
+    const creds = readEasCredentials(ctx.credentials);
+    const serviceName = this.config.serviceName ?? this.config.appId;
+    const maxLookbackMs = this.config.maxLookbackMs ?? DEFAULT_MAX_LOOKBACK_MS6;
+    const sinceIso = boundedSinceIso2(ctx.since, /* @__PURE__ */ new Date(), maxLookbackMs);
+    const builds = await fetchErroredBuilds(creds.token, this.config, this.fetchImpl);
+    const fresh = builds.filter((b) => isBuildSince(b, sinceIso));
+    const maxLogBytes = this.config.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES;
+    for (const build of fresh) {
+      build.logsText = await fetchBuildLogs(build.logFileUrls, maxLogBytes, this.fetchImpl);
+    }
+    return mapBuildsToSignals(fresh, serviceName);
+  }
+};
+function createEasConnector(graph, config, fetchImpl) {
+  return {
+    connector: new EasConnector(config, fetchImpl),
+    resolveTarget: createEasResolveTarget(graph)
+  };
+}
+
 // src/connectors/registry.ts
 var CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4";
 async function authProbe(input) {
@@ -16874,6 +17670,41 @@ var PROVIDER_DISPATCH = {
         ...fetchImpl ? { fetchImpl } : {}
       });
     }
+  },
+  eas: {
+    provider: "eas",
+    // The secret is a single robot-user EXPO_TOKEN; a single-string credential
+    // maps to `token`. `appId` is non-secret config (connector-config.md §7.1).
+    primaryCredentialKey: "token",
+    requiredCredentialFields: ["token"],
+    requiredOptionFields: ["appId"],
+    build(graph, options) {
+      return createEasConnector(graph, options);
+    },
+    // Runs the connector's real `builds` query at limit 1 — the exact read poll()
+    // performs, minus the pages — so the probe checks both that the EXPO_TOKEN
+    // authenticates and that this app id is reachable, the same probe-the-real-
+    // query discipline Railway and Cloud Run use over a trivial `{ __typename }`.
+    // A bad or wrong-scoped token comes back as an Expo GraphQL error, which
+    // `fetchErroredBuilds` throws on, so it fails honestly here rather than
+    // silently at the first poll.
+    async validate({ credentials, options, fetchImpl }) {
+      const cfg = options;
+      const appId = String(cfg.appId ?? "");
+      if (!appId) return { ok: false, reason: "eas: appId is required to validate" };
+      const probeConfig = {
+        appId,
+        pageSize: 1,
+        maxPages: 1,
+        ...cfg.apiUrl ? { apiUrl: cfg.apiUrl } : {}
+      };
+      try {
+        await fetchErroredBuilds(String(credentials.token ?? ""), probeConfig, fetchImpl);
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, reason: `eas auth check failed: ${err.message}` };
+      }
+    }
   }
 };
 function vercelCredsFrom(credentials) {
@@ -17086,7 +17917,11 @@ async function startConnectorPolling(input) {
   const stopFns = all.map(
     (registration) => startConnectorPollLoop(
       registration.connector,
-      { projectDir: input.projectDir, credentials: registration.credentials },
+      {
+        projectDir: input.projectDir,
+        credentials: registration.credentials,
+        ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
+      },
       input.graph,
       registration.resolveTarget,
       { intervalMs: registration.intervalMs, connectorId: registration.id }
@@ -17415,10 +18250,15 @@ function registerRoutes(scope, ctx) {
       }
       const reg = built.registration;
       const at = (/* @__PURE__ */ new Date()).toISOString();
+      const incidentsPath = errorsPathFor(proj);
       try {
         const result = await ctx.runPoll(
           reg.connector,
-          { projectDir: proj.scanPath ?? "", credentials: reg.credentials },
+          {
+            projectDir: proj.scanPath ?? "",
+            credentials: reg.credentials,
+            ...incidentsPath ? { errorsPath: incidentsPath } : {}
+          },
           proj.graph,
           reg.resolveTarget
         );
@@ -17488,6 +18328,34 @@ function registerRoutes(scope, ctx) {
     }
     return getBlastRadius(proj.graph, nodeId, depth);
   });
+  scope.get("/graph/expand/:nodeId", async (req, reply) => {
+    const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    const { nodeId } = req.params;
+    if (!proj.graph.hasNode(nodeId)) {
+      return reply.code(404).send({ error: "node not found", id: nodeId });
+    }
+    const direction = req.query.direction;
+    if (direction !== "up" && direction !== "down") {
+      return reply.code(400).send({ error: 'direction must be "up" or "down"' });
+    }
+    const epath = errorsPathFor(proj);
+    const incidents = epath ? await readErrorEvents(epath) : [];
+    return expandNode(proj.graph, nodeId, direction, incidents);
+  });
+  scope.get("/graph/relate", async (req, reply) => {
+    const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    const { a, b } = req.query;
+    if (!a || !b) {
+      return reply.code(400).send({ error: "both a and b query params are required" });
+    }
+    const maxDepth = req.query.maxDepth ? Number(req.query.maxDepth) : void 0;
+    if (maxDepth !== void 0 && (!Number.isFinite(maxDepth) || maxDepth < 1)) {
+      return reply.code(400).send({ error: "maxDepth must be a positive integer" });
+    }
+    return relate(proj.graph, a, b, maxDepth);
+  });
   scope.get("/search", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
@@ -17981,8 +18849,8 @@ export {
   emitNeatEvent,
   attachGraphToEventBus,
   confidenceForEdge,
-  getRootCause,
   getBlastRadius,
+  getRootCause,
   evaluateAllPolicies,
   loadPolicyFile,
   PolicyViolationsLog,
@@ -18056,4 +18924,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-N5TPODCX.js.map
+//# sourceMappingURL=chunk-3PXRQH53.js.map